commit 5c4608656e26465d9c9f34fcd8b38b7e1b9a685a · pyrox.dev/nixpkgs

+83

ci/eval/attrpaths.nix

···

       1
       1
       +
       # This expression will, as efficiently as possible, dump a

     

       2
       2
       +
       # *superset* of all attrpaths of derivations which might be

     

       3
       3
       +
       # part of a release on *any* platform.

     

       4
       4
       +
       #

     

       5
       5
       +
       # This expression runs single-threaded under all current Nix

     

       6
       6
       +
       # implementations, but much faster and with much less memory

     

       7
       7
       +
       # used than ./outpaths.nix itself.

     

       8
       8
       +
       #

     

       9
       9
       +
       # Once you have the list of attrnames you can split it up into

     

       10
       10
       +
       # $NUM_CORES batches and evaluate the outpaths separately for each

     

       11
       11
       +
       # batch, in parallel.

     

       12
       12
       +
       #

     

       13
       13
       +
       # To dump the attrnames:

     

       14
       14
       +
       #

     

       15
       15
       +
       #   nix-instantiate --eval --strict --json ci/eval/attrpaths.nix -A names

     

       16
       16
       +
       #

     

       17
       17
       +
       {

     

       18
       18
       +
         lib ? import (path + "/lib"),

     

       19
       19
       +
         trace ? false,

     

       20
       20
       +
         path ? ./../..,

     

       21
       21
       +
       }:

     

       22
       22
       +
       let

     

       23
       23
       +
       

     

       24
       24
       +
         # TODO: Use mapAttrsToListRecursiveCond when this PR lands:

     

       25
       25
       +
         # https://github.com/NixOS/nixpkgs/pull/395160

     

       26
       26
       +
         justAttrNames =

     

       27
       27
       +
           path: value:

     

       28
       28
       +
           let

     

       29
       29
       +
             result =

     

       30
       30
       +
               if path == [ "AAAAAASomeThingsFailToEvaluate" ] || !(lib.isAttrs value) then

     

       31
       31
       +
                 [ ]

     

       32
       32
       +
               else if lib.isDerivation value then

     

       33
       33
       +
                 [ path ]

     

       34
       34
       +
               else

     

       35
       35
       +
                 lib.pipe value [

     

       36
       36
       +
                   (lib.mapAttrsToList (

     

       37
       37
       +
                     name: value:

     

       38
       38
       +
                     lib.addErrorContext "while evaluating package set attribute path '${

     

       39
       39
       +
                       lib.showAttrPath (path ++ [ name ])

     

       40
       40
       +
                     }'" (justAttrNames (path ++ [ name ]) value)

     

       41
       41
       +
                   ))

     

       42
       42
       +
                   lib.concatLists

     

       43
       43
       +
                 ];

     

       44
       44
       +
           in

     

       45
       45
       +
           lib.traceIf trace "** ${lib.showAttrPath path}" result;

     

       46
       46
       +
       

     

       47
       47
       +
         outpaths = import ./outpaths.nix {

     

       48
       48
       +
           inherit path;

     

       49
       49
       +
           attrNamesOnly = true;

     

       50
       50
       +
         };

     

       51
       51
       +
       

     

       52
       52
       +
         paths = [

     

       53
       53
       +
           # Some of the following are based on variants, which are disabled with `attrNamesOnly = true`.

     

       54
       54
       +
           # Until these have been removed from release.nix / hydra, we manually add them to the list.

     

       55
       55
       +
           [

     

       56
       56
       +
             "pkgsLLVM"

     

       57
       57
       +
             "stdenv"

     

       58
       58
       +
           ]

     

       59
       59
       +
           [

     

       60
       60
       +
             "pkgsArocc"

     

       61
       61
       +
             "stdenv"

     

       62
       62
       +
           ]

     

       63
       63
       +
           [

     

       64
       64
       +
             "pkgsZig"

     

       65
       65
       +
             "stdenv"

     

       66
       66
       +
           ]

     

       67
       67
       +
           [

     

       68
       68
       +
             "pkgsStatic"

     

       69
       69
       +
             "stdenv"

     

       70
       70
       +
           ]

     

       71
       71
       +
           [

     

       72
       72
       +
             "pkgsMusl"

     

       73
       73
       +
             "stdenv"

     

       74
       74
       +
           ]

     

       75
       75
       +
         ]

     

       76
       76
       +
         ++ justAttrNames [ ] outpaths;

     

       77
       77
       +
       

     

       78
       78
       +
         names = map lib.showAttrPath paths;

     

       79
       79
       +
       

     

       80
       80
       +
       in

     

       81
       81
       +
       {

     

       82
       82
       +
         inherit paths names;

     

       83
       83
       +
       }

-1

ci/eval/compare/default.nix

···

       105
       105
        
                 ) rebuildsByKernel

     

       106
       106
        
                 # Set the "11.by: package-maintainer" label to whether all packages directly

     

       107
       107
        
                 # changed are maintained by the PR's author.

     

       108
       108
       -
                 # (https://github.com/NixOS/ofborg/blob/df400f44502d4a4a80fa283d33f2e55a4e43ee90/ofborg/src/tagger.rs#L83-L88)

     

       109
       108
        
                 // {

     

       110
       109
        
                   "11.by: package-maintainer" =

     

       111
       110
        
                     maintainers ? ${githubAuthorId}

-1

ci/eval/compare/maintainers.nix

···

       1
       1
        
       {

     

       2
       2
        
         lib,

     

       3
       3
        
       }:

     

       4
       4
       -
       # Almost directly vendored from https://github.com/NixOS/ofborg/blob/5a4e743f192fb151915fcbe8789922fa401ecf48/ofborg/src/maintainers.nix

     

       5
       4
        
       {

     

       6
       5
        
         changedattrs,

     

       7
       6
        
         changedpathsjson,

+7 -6

ci/eval/default.nix

···

       26
       26
        
             root = ../..;

     

       27
       27
        
             fileset = unions (

     

       28
       28
        
               map (lib.path.append ../..) [

     

       29
       29
       +
                 ".version"

     

       30
       30
       +
                 "ci/supportedSystems.json"

     

       31
       31
       +
                 "ci/eval/attrpaths.nix"

     

       32
       32
       +
                 "ci/eval/chunk.nix"

     

       33
       33
       +
                 "ci/eval/outpaths.nix"

     

       29
       34
        
                 "default.nix"

     

       30
       35
        
                 "doc"

     

       31
       36
        
                 "lib"

     
···

       33
       38
        
                 "modules"

     

       34
       39
        
                 "nixos"

     

       35
       40
        
                 "pkgs"

     

       36
       36
       -
                 ".version"

     

       37
       37
       -
                 "ci/supportedSystems.json"

     

       38
       41
        
               ]

     

       39
       42
        
             );

     

       40
       43
        
           };

     
···

       60
       63
        
               export GC_INITIAL_HEAP_SIZE=4g

     

       61
       64
        
               command time -f "Attribute eval done [%MKB max resident, %Es elapsed] %C" \

     

       62
       65
        
                 nix-instantiate --eval --strict --json --show-trace \

     

       63
       63
       -
                   "$src/pkgs/top-level/release-attrpaths-superset.nix" \

     

       66
       66
       +
                   "$src/ci/eval/attrpaths.nix" \

     

       64
       67
        
                   -A paths \

     

       65
       68
        
                   -I "$src" \

     

       66
       69
        
                   --option restrict-eval true \

     
···

       78
       81
        
             attrpathFile ? "${attrpathsSuperset { inherit evalSystem; }}/paths.json",

     

       79
       82
        
             # The number of attributes per chunk, see ./README.md for more info.

     

       80
       83
        
             chunkSize ? 5000,

     

       81
       81
       -
             checkMeta ? true,

     

       82
       84
        
       

     

       83
       85
        
             # Don't try to eval packages marked as broken.

     

       84
       86
        
             includeBroken ? false,

     
···

       99
       101
        
               set +e

     

       100
       102
        
               command time -o "$outputDir/timestats/$myChunk" \

     

       101
       103
        
                 -f "Chunk $myChunk on $system done [%MKB max resident, %Es elapsed] %C" \

     

       102
       102
       -
                 nix-env -f "${nixpkgs}/pkgs/top-level/release-outpaths-parallel.nix" \

     

       104
       104
       +
                 nix-env -f "${nixpkgs}/ci/eval/chunk.nix" \

     

       103
       105
        
                 --eval-system "$system" \

     

       104
       106
        
                 --option restrict-eval true \

     

       105
       107
        
                 --option allow-import-from-derivation false \

     
···

       110
       112
        
                 --arg myChunk "$myChunk" \

     

       111
       113
        
                 --arg attrpathFile "${attrpathFile}" \

     

       112
       114
        
                 --arg systems "[ \"$system\" ]" \

     

       113
       113
       -
                 --arg checkMeta ${lib.boolToString checkMeta} \

     

       114
       115
        
                 --arg includeBroken ${lib.boolToString includeBroken} \

     

       115
       116
        
                 -I ${nixpkgs} \

     

       116
       117
        
                 -I ${attrpathFile} \

+1 -3

pkgs/test/default.nix

···

       152
       152
        
       

     

       153
       153
        
         php = recurseIntoAttrs (callPackages ./php { });

     

       154
       154
        
       

     

       155
       155
       -
         pkg-config = recurseIntoAttrs (callPackage ../top-level/pkg-config/tests.nix { }) // {

     

       156
       156
       -
           __recurseIntoDerivationForReleaseJobs = true;

     

       157
       157
       -
         };

     

       155
       155
       +
         pkg-config = recurseIntoAttrs (callPackage ../top-level/pkg-config/tests.nix { });

     

       158
       156
        
       

     

       159
       157
        
         buildRustCrate = recurseIntoAttrs (callPackage ../build-support/rust/build-rust-crate/test { });

     

       160
       158
        
         importCargoLock = recurseIntoAttrs (callPackage ../build-support/rust/test/import-cargo-lock { });

+13 -20

pkgs/top-level/all-packages.nix

···

       5165
       5165
        
                 haskell.packages.ghc96

     

       5166
       5166
        
               else

     

       5167
       5167
        
                 haskell.packages.ghc98

     

       5168
       5168
       -
             )

     

       5169
       5169
       -
           // {

     

       5170
       5170
       -
             __recurseIntoDerivationForReleaseJobs = true;

     

       5171
       5171
       -
           };

     

       5168
       5168
       +
             );

     

       5172
       5169
        
       

     

       5173
       5170
        
         # haskellPackages.ghc is build->host (it exposes the compiler used to build the

     

       5174
       5171
        
         # set, similarly to stdenv.cc), but pkgs.ghc should be host->target to be more

     
···

       8849
       8846
        
           }

     

       8850
       8847
        
         );

     

       8851
       8848
        
       

     

       8852
       8852
       -
         libsForQt5 =

     

       8853
       8853
       -
           (recurseIntoAttrs (

     

       8854
       8854
       -
             import ./qt5-packages.nix {

     

       8855
       8855
       -
               inherit

     

       8856
       8856
       -
                 lib

     

       8857
       8857
       -
                 config

     

       8858
       8858
       -
                 __splicedPackages

     

       8859
       8859
       -
                 makeScopeWithSplicing'

     

       8860
       8860
       -
                 generateSplicesForMkScope

     

       8861
       8861
       -
                 pkgsHostTarget

     

       8862
       8862
       -
                 ;

     

       8863
       8863
       -
             }

     

       8864
       8864
       -
           ))

     

       8865
       8865
       -
           // {

     

       8866
       8866
       -
             __recurseIntoDerivationForReleaseJobs = true;

     

       8867
       8867
       -
           };

     

       8849
       8849
       +
         libsForQt5 = recurseIntoAttrs (

     

       8850
       8850
       +
           import ./qt5-packages.nix {

     

       8851
       8851
       +
             inherit

     

       8852
       8852
       +
               lib

     

       8853
       8853
       +
               config

     

       8854
       8854
       +
               __splicedPackages

     

       8855
       8855
       +
               makeScopeWithSplicing'

     

       8856
       8856
       +
               generateSplicesForMkScope

     

       8857
       8857
       +
               pkgsHostTarget

     

       8858
       8858
       +
               ;

     

       8859
       8859
       +
           }

     

       8860
       8860
       +
         );

     

       8868
       8861
        
       

     

       8869
       8862
        
         # plasma5Packages maps to the Qt5 packages set that is used to build the plasma5 desktop

     

       8870
       8863
        
         plasma5Packages = libsForQt5;

-1

pkgs/top-level/linux-kernels.nix

···

       781
       781
        
             linux_libre = recurseIntoAttrs (packagesFor kernels.linux_libre);

     

       782
       782
        
       

     

       783
       783
        
             linux_latest_libre = recurseIntoAttrs (packagesFor kernels.linux_latest_libre);

     

       784
       784
       -
             __recurseIntoDerivationForReleaseJobs = true;

     

       785
       784
        
           }

     

       786
       785
        
           // lib.optionalAttrs config.allowAliases {

     

       787
       786

+1 -3

pkgs/top-level/pkg-config/tests.nix

···

       22
       22
        
         };

     

       23
       23
        
       in

     

       24
       24
        
       lib.recurseIntoAttrs {

     

       25
       25
       -
         defaultPkgConfigPackages = allPkgs.callPackage ./test-defaultPkgConfigPackages.nix { } // {

     

       26
       26
       -
           __recurseIntoDerivationForReleaseJobs = true;

     

       27
       27
       -
         };

     

       25
       25
       +
         defaultPkgConfigPackages = allPkgs.callPackage ./test-defaultPkgConfigPackages.nix { };

     

       28
       26
        
       }

-114

pkgs/top-level/release-attrpaths-superset.nix

···

       1
       1
       -
       # This expression will, as efficiently as possible, dump a

     

       2
       2
       -
       # *superset* of all attrpaths of derivations which might be

     

       3
       3
       -
       # part of a release on *any* platform.

     

       4
       4
       -
       #

     

       5
       5
       -
       # Both this expression and what ofborg uses (release-outpaths.nix)

     

       6
       6
       -
       # are essentially single-threaded (under the current cppnix

     

       7
       7
       -
       # implementation).

     

       8
       8
       -
       #

     

       9
       9
       -
       # This expression runs much, much, much faster and uses much, much

     

       10
       10
       -
       # less memory than the ofborg script by skipping the

     

       11
       11
       -
       # platform-relevance checks.  The ofborg outpaths.nix script takes

     

       12
       12
       -
       # half an hour on a 3ghz core and peaks at 60gbytes of memory; this

     

       13
       13
       -
       # expression runs on the same machine in 44 seconds with peak memory

     

       14
       14
       -
       # usage of 5gbytes.

     

       15
       15
       -
       #

     

       16
       16
       -
       # Once you have the list of attrnames you can split it up into

     

       17
       17
       -
       # $NUM_CORES batches and run the platform checks separately for each

     

       18
       18
       -
       # batch, in parallel.

     

       19
       19
       -
       #

     

       20
       20
       -
       # To dump the attrnames:

     

       21
       21
       -
       #

     

       22
       22
       -
       #   nix-instantiate --eval --strict --json pkgs/top-level/release-attrpaths-superset.nix -A names

     

       23
       23
       -
       #

     

       24
       24
       -
       {

     

       25
       25
       -
         lib ? import (path + "/lib"),

     

       26
       26
       -
         trace ? false,

     

       27
       27
       -
         checkMeta ? true,

     

       28
       28
       -
         path ? ./../..,

     

       29
       29
       -
       }:

     

       30
       30
       -
       let

     

       31
       31
       -
       

     

       32
       32
       -
         # The intended semantics are that an attrpath rooted at pkgs is

     

       33
       33
       -
         # part of the (unfiltered) release jobset iff both of the following

     

       34
       34
       -
         # are true:

     

       35
       35
       -
         #

     

       36
       36
       -
         # 1. The attrpath leads to a value for which lib.isDerivation is true

     

       37
       37
       -
         #

     

       38
       38
       -
         # 2. Any proper prefix of the attrpath at which lib.isDerivation

     

       39
       39
       -
         #    is true also has __recurseIntoDerivationForReleaseJobs=true.

     

       40
       40
       -
         #

     

       41
       41
       -
         # The second condition is unfortunately necessary because there are

     

       42
       42
       -
         # Hydra release jobnames which have proper prefixes which are

     

       43
       43
       -
         # attrnames of derivations (!).  We should probably restructure

     

       44
       44
       -
         # the job tree so that this is not the case.

     

       45
       45
       -
         #

     

       46
       46
       -
         justAttrNames =

     

       47
       47
       -
           path: value:

     

       48
       48
       -
           let

     

       49
       49
       -
             result =

     

       50
       50
       -
               if path == [ "AAAAAASomeThingsFailToEvaluate" ] then

     

       51
       51
       -
                 [ ]

     

       52
       52
       -
               else if

     

       53
       53
       -
                 lib.isDerivation value

     

       54
       54
       -
                 &&

     

       55
       55
       -
                   # in some places we have *derivations* with jobsets as subattributes, ugh

     

       56
       56
       -
                   !(value.__recurseIntoDerivationForReleaseJobs or false)

     

       57
       57
       -
               then

     

       58
       58
       -
                 [ path ]

     

       59
       59
       -
       

     

       60
       60
       -
               # Even wackier case: we have meta.broken==true jobs with

     

       61
       61
       -
               # !meta.broken jobs as subattributes with license=unfree, and

     

       62
       62
       -
               # check-meta.nix won't throw an "unfree" failure because the

     

       63
       63
       -
               # enclosing derivation is marked broken.  Yeah.  Bonkers.

     

       64
       64
       -
               # We should just forbid jobsets enclosed by derivations.

     

       65
       65
       -
               else if lib.isDerivation value && !value.meta.available then

     

       66
       66
       -
                 [ ]

     

       67
       67
       -
       

     

       68
       68
       -
               else if !(lib.isAttrs value) then

     

       69
       69
       -
                 [ ]

     

       70
       70
       -
               else

     

       71
       71
       -
                 lib.pipe value [

     

       72
       72
       -
                   (builtins.mapAttrs (

     

       73
       73
       -
                     name: value:

     

       74
       74
       -
                     builtins.addErrorContext "while evaluating package set attribute path '${

     

       75
       75
       -
                       lib.showAttrPath (path ++ [ name ])

     

       76
       76
       -
                     }'" (justAttrNames (path ++ [ name ]) value)

     

       77
       77
       -
                   ))

     

       78
       78
       -
                   builtins.attrValues

     

       79
       79
       -
                   builtins.concatLists

     

       80
       80
       -
                 ];

     

       81
       81
       -
           in

     

       82
       82
       -
           if !trace then result else lib.trace "** ${lib.concatStringsSep "." path}" result;

     

       83
       83
       -
       

     

       84
       84
       -
         releaseOutpaths = import ./release-outpaths.nix {

     

       85
       85
       -
           inherit checkMeta;

     

       86
       86
       -
           attrNamesOnly = true;

     

       87
       87
       -
           inherit path;

     

       88
       88
       -
         };

     

       89
       89
       -
       

     

       90
       90
       -
         paths = [

     

       91
       91
       -
           # I am not entirely sure why these three packages end up in

     

       92
       92
       -
           # the Hydra jobset.  But they do, and they don't meet the

     

       93
       93
       -
           # criteria above, so at the moment they are special-cased.

     

       94
       94
       -
           [

     

       95
       95
       -
             "pkgsLLVM"

     

       96
       96
       -
             "stdenv"

     

       97
       97
       -
           ]

     

       98
       98
       -
           [

     

       99
       99
       -
             "pkgsStatic"

     

       100
       100
       -
             "stdenv"

     

       101
       101
       -
           ]

     

       102
       102
       -
           [

     

       103
       103
       -
             "pkgsMusl"

     

       104
       104
       -
             "stdenv"

     

       105
       105
       -
           ]

     

       106
       106
       -
         ]

     

       107
       107
       -
         ++ justAttrNames [ ] releaseOutpaths;

     

       108
       108
       -
       

     

       109
       109
       -
         names = map (path: (lib.concatStringsSep "." path)) paths;

     

       110
       110
       -
       

     

       111
       111
       -
       in

     

       112
       112
       -
       {

     

       113
       113
       -
         inherit paths names;

     

       114
       114
       -
       }

+3 -5

pkgs/top-level/release-outpaths-parallel.nix ci/eval/chunk.nix

···

       1
       1
       -
       # This file works in tandem with ../../ci/eval/default.nix

     

       2
       2
       -
       # It turns ./release-outpaths.nix into chunks of a fixed size

     

       1
       1
       +
       # This turns ./outpaths.nix into chunks of a fixed size.

     

       3
       2
        
       {

     

       4
       3
        
         lib ? import ../../lib,

     

       5
       4
        
         path ? ../..,

     
···

       7
       6
        
         attrpathFile,

     

       8
       7
        
         chunkSize,

     

       9
       8
        
         myChunk,

     

       10
       10
       -
         checkMeta,

     

       11
       9
        
         includeBroken,

     

       12
       10
        
         systems,

     

       13
       11
        
       }:

     
···

       16
       14
        
         attrpaths = lib.importJSON attrpathFile;

     

       17
       15
        
         myAttrpaths = lib.sublist (chunkSize * myChunk) chunkSize attrpaths;

     

       18
       16
        
       

     

       19
       19
       -
         unfiltered = import ./release-outpaths.nix {

     

       17
       17
       +
         unfiltered = import ./outpaths.nix {

     

       20
       18
        
           inherit path;

     

       21
       21
       -
           inherit checkMeta includeBroken systems;

     

       19
       19
       +
           inherit includeBroken systems;

     

       22
       20
        
         };

     

       23
       21
        
       

     

       24
       22
        
         # Turns the unfiltered recursive attribute set into one that is limited to myAttrpaths

+4 -7

pkgs/top-level/release-outpaths.nix ci/eval/outpaths.nix

···

       1
       1
        
       #!/usr/bin/env nix-shell

     

       2
       2
        
       # When using as a callable script, passing `--argstr path some/path` overrides $PWD.

     

       3
       3
       -
       #!nix-shell -p nix -i "nix-env -qaP --no-name --out-path --arg checkMeta true -f pkgs/top-level/release-outpaths.nix"

     

       3
       3
       +
       #!nix-shell -p nix -i "nix-env -qaP --no-name --out-path -f ci/eval/outpaths.nix"

     

       4
       4
        
       

     

       5
       5
       -
       # Vendored from:

     

       6
       6
       -
       #   https://raw.githubusercontent.com/NixOS/ofborg/74f38efa7ef6f0e8e71ec3bfc675ae4fb57d7491/ofborg/src/outpaths.nix

     

       7
       5
        
       {

     

       8
       8
       -
         checkMeta,

     

       9
       6
        
         includeBroken ? true, # set this to false to exclude meta.broken packages from the output

     

       10
       7
        
         path ? ./../..,

     

       11
       8
        
       

     

       12
       12
       -
         # used by pkgs/top-level/release-attrnames-superset.nix

     

       9
       9
       +
         # used by ./attrpaths.nix

     

       13
       10
        
         attrNamesOnly ? false,

     

       14
       11
        
       

     

       15
       12
        
         # Set this to `null` to build for builtins.currentSystem only

     

       16
       16
       -
         systems ? builtins.fromJSON (builtins.readFile ../../ci/supportedSystems.json),

     

       13
       13
       +
         systems ? builtins.fromJSON (builtins.readFile ../supportedSystems.json),

     

       17
       14
        
       }:

     

       18
       15
        
       let

     

       19
       16
        
         lib = import (path + "/lib");

     
···

       30
       27
        
                   allowUnfree = true;

     

       31
       28
        
                   allowInsecurePredicate = x: true;

     

       32
       29
        
                   allowVariants = !attrNamesOnly;

     

       33
       33
       -
                   checkMeta = checkMeta;

     

       30
       30
       +
                   checkMeta = true;

     

       34
       31
        
       

     

       35
       32
        
                   handleEvalIssue =

     

       36
       33
        
                     reason: errormsg:

+1 -5

pkgs/top-level/release-python.nix

···

       36
       36
        
             res = builtins.tryEval (

     

       37
       37
        
               if isDerivation value then

     

       38
       38
        
                 value.meta.isBuildPythonPackage or [ ]

     

       39
       39
       -
               else if

     

       40
       40
       -
                 value.recurseForDerivations or false

     

       41
       41
       -
                 || value.recurseForRelease or false

     

       42
       42
       -
                 || value.__recurseIntoDerivationForReleaseJobs or false

     

       43
       43
       -
               then

     

       39
       39
       +
               else if value.recurseForDerivations or false || value.recurseForRelease or false then

     

       44
       40
        
                 packagePython value

     

       45
       41
        
               else

     

       46
       42
        
                 [ ]

+1 -5

pkgs/top-level/release-unfree-redistributable.nix

···

       69
       69
        
                     value.meta.hydraPlatforms

     

       70
       70
        
                       or (lib.subtractLists (value.meta.badPlatforms or [ ]) (value.meta.platforms or [ "x86_64-linux" ]))

     

       71
       71
        
                   )

     

       72
       72
       -
                 else if

     

       73
       73
       -
                   value.recurseForDerivations or false

     

       74
       74
       -
                   || value.recurseForRelease or false

     

       75
       75
       -
                   || value.__recurseIntoDerivationForReleaseJobs or false

     

       76
       76
       -
                 then

     

       72
       72
       +
                 else if value.recurseForDerivations or false || value.recurseForRelease or false then

     

       77
       73
        
                   # Recurse

     

       78
       74
        
                   packagesWith attrPath cond value

     

       79
       75
        
                 else

+4 -6

pkgs/top-level/release.nix

···

       57
       57
        
         # resulting tree of attributes to *not* have a ".${system}"

     

       58
       58
        
         # suffixed upon every job name like Hydra expects.

     

       59
       59
        
         #

     

       60
       60
       -
         # This flag exists mainly for use by

     

       61
       61
       -
         # pkgs/top-level/release-attrnames-superset.nix; see that file for

     

       62
       62
       -
         # full details.  The exact behavior of this flag may change; it

     

       63
       63
       -
         # should be considered an internal implementation detail of

     

       64
       64
       -
         # pkgs/top-level/.

     

       65
       65
       -
         #

     

       60
       60
       +
         # This flag exists mainly for use by ci/eval/attrpaths.nix; see

     

       61
       61
       +
         # that file for full details.  The exact behavior of this flag

     

       62
       62
       +
         # may change; it should be considered an internal implementation

     

       63
       63
       +
         # detail of ci/eval.

     

       66
       64
        
         attrNamesOnly ? false,

     

       67
       65
        
       }:

     

       68
       66