commit d3ca5027fabc6f3c8df7849fcbb7afaa3903c17b · pyrox.dev/nixpkgs

+4 -4

doc/languages-frameworks/dotnet.section.md

···

       98
        
       For more detail about managing the `deps.nix` file, see [Generating and updating NuGet dependencies](#generating-and-updating-nuget-dependencies)

     

       99
        
       :::

     

       100
        
       

     

       101
       -
       * `packNupkg` is used to pack project as a `nupkg`, and installs it to `$out/share`. If set to `true`, the derivation can be used as a dependency for another dotnet project by adding it to `projectReferences`.

     

       102
       -
       * `projectReferences` can be used to resolve `ProjectReference` project items. Referenced projects can be packed with `buildDotnetModule` by setting the `packNupkg = true` attribute and passing a list of derivations to `projectReferences`. Since we are sharing referenced projects as NuGets they must be added to csproj/fsproj files as `PackageReference` as well.

     

       103
        
        For example, your project has a local dependency:

     

       104
        
        ```xml

     

       105
        
            <ProjectReference Include="../foo/bar.fsproj" />

     

       106
        
        ```

     

       107
       -
        To enable discovery through `projectReferences` you would need to add:

     

       108
        
        ```xml

     

       109
        
            <ProjectReference Include="../foo/bar.fsproj" />

     

       110
        
            <PackageReference Include="bar" Version="*" Condition=" '$(ContinuousIntegrationBuild)'=='true' "/>

     
···

       143
        
         projectFile = "src/project.sln";

     

       144
        
         nugetDeps = ./deps.nix; # see "Generating and updating NuGet dependencies" section for details

     

       145
        
       

     

       146
       -
         projectReferences = [ referencedProject ]; # `referencedProject` must contain `nupkg` in the folder structure.

     

       147
        
       

     

       148
        
         dotnet-sdk = dotnetCorePackages.sdk_6_0;

     

       149
        
         dotnet-runtime = dotnetCorePackages.runtime_6_0;

···

       98
        
       For more detail about managing the `deps.nix` file, see [Generating and updating NuGet dependencies](#generating-and-updating-nuget-dependencies)

     

       99
        
       :::

     

       100
        
       

     

       101
       +
       * `packNupkg` is used to pack project as a `nupkg`, and installs it to `$out/share`. If set to `true`, the derivation can be used as a dependency for another dotnet project by adding it to `buildInputs`.

     

       102
       +
       * `buildInputs` can be used to resolve `ProjectReference` project items. Referenced projects can be packed with `buildDotnetModule` by setting the `packNupkg = true` attribute and passing a list of derivations to `buildInputs`. Since we are sharing referenced projects as NuGets they must be added to csproj/fsproj files as `PackageReference` as well.

     

       103
        
        For example, your project has a local dependency:

     

       104
        
        ```xml

     

       105
        
            <ProjectReference Include="../foo/bar.fsproj" />

     

       106
        
        ```

     

       107
       +
        To enable discovery through `buildInputs` you would need to add:

     

       108
        
        ```xml

     

       109
        
            <ProjectReference Include="../foo/bar.fsproj" />

     

       110
        
            <PackageReference Include="bar" Version="*" Condition=" '$(ContinuousIntegrationBuild)'=='true' "/>

     
···

       143
        
         projectFile = "src/project.sln";

     

       144
        
         nugetDeps = ./deps.nix; # see "Generating and updating NuGet dependencies" section for details

     

       145
        
       

     

       146
       +
         buildInputs = [ referencedProject ]; # `referencedProject` must contain `nupkg` in the folder structure.

     

       147
        
       

     

       148
        
         dotnet-sdk = dotnetCorePackages.sdk_6_0;

     

       149
        
         dotnet-runtime = dotnetCorePackages.runtime_6_0;

pkgs/build-support/dotnet/build-dotnet-global-tool/default.nix

···

       28
        
           nugetDeps = { fetchNuGet }: [

     

       29
        
             (fetchNuGet { pname = nugetName; inherit version; sha256 = nugetSha256; hash = nugetHash; })

     

       30
        
           ] ++ (nugetDeps fetchNuGet);

     

       0
        
       
     

       31
        
         };

     

       32
        
       

     

       33
        
         dotnetGlobalTool = true;

···

       28
        
           nugetDeps = { fetchNuGet }: [

     

       29
        
             (fetchNuGet { pname = nugetName; inherit version; sha256 = nugetSha256; hash = nugetHash; })

     

       30
        
           ] ++ (nugetDeps fetchNuGet);

     

       31
       +
           installable = true;

     

       32
        
         };

     

       33
        
       

     

       34
        
         dotnetGlobalTool = true;

+48 -80

pkgs/build-support/dotnet/build-dotnet-module/default.nix

···

       4
        
       , callPackage

     

       5
        
       , substituteAll

     

       6
        
       , writeShellScript

     

       7
       -
       , srcOnly

     

       8
       -
       , linkFarmFromDrvs

     

       9
       -
       , symlinkJoin

     

       10
        
       , makeWrapper

     

       11
        
       , dotnetCorePackages

     

       12
       -
       , mkNugetSource

     

       13
        
       , mkNugetDeps

     

       14
        
       , nuget-to-nix

     

       15
        
       , cacert

     

       16
       -
       , coreutils

     

       17
       -
       , runtimeShellPackage

     

       0
        
       
     

       18
        
       }:

     

       19
        
       

     

       20
        
       { name ? "${_args.pname}-${_args.version}"

     
···

       106
        
           inherit dotnet-sdk dotnet-runtime;

     

       107
        
         }) dotnetConfigureHook dotnetBuildHook dotnetCheckHook dotnetInstallHook dotnetFixupHook;

     

       108
        
       

     

       109
       -
         localDeps =

     

       110
       -
           if (projectReferences != [ ])

     

       111
       -
           then linkFarmFromDrvs "${name}-project-references" projectReferences

     

       112
       -
           else null;

     

       113
       -
       

     

       114
        
         _nugetDeps =

     

       115
        
           if (nugetDeps != null) then

     

       116
        
             if lib.isDerivation nugetDeps

     
···

       121
        
             }

     

       122
        
           else throw "Defining the `nugetDeps` attribute is required, as to lock the NuGet dependencies. This file can be generated by running the `passthru.fetch-deps` script.";

     

       123
        
       

     

       124
       -
         # contains the actual package dependencies

     

       125
       -
         dependenciesSource = mkNugetSource {

     

       126
       -
           name = "${name}-dependencies-source";

     

       127
       -
           description = "Nuget source with the dependencies for ${name}";

     

       128
       -
           deps = [ _nugetDeps ] ++ lib.optional (localDeps != null) localDeps;

     

       129
       -
         };

     

       130
       -
       

     

       131
       -
         # this contains all the nuget packages that are implicitly referenced by the dotnet

     

       132
       -
         # build system. having them as separate deps allows us to avoid having to regenerate

     

       133
       -
         # a packages dependencies when the dotnet-sdk version changes

     

       134
       -
         sdkDeps = lib.lists.flatten [ dotnet-sdk.packages ];

     

       135
       -
       

     

       136
       -
         sdkSource = let

     

       137
       -
           version = dotnet-sdk.version or (lib.concatStringsSep "-" dotnet-sdk.versions);

     

       138
       -
         in mkNugetSource {

     

       139
       -
           name = "dotnet-sdk-${version}-source";

     

       140
       -
           deps = sdkDeps;

     

       141
       -
         };

     

       142
       -
       

     

       143
       -
         nuget-source = symlinkJoin {

     

       144
       -
           name = "${name}-nuget-source";

     

       145
       -
           paths = [ dependenciesSource sdkSource ];

     

       146
       -
         };

     

       147
       -
       

     

       148
        
         nugetDepsFile = _nugetDeps.sourceFile;

     

       0
        
       
     

       0
        
       
     

       149
        
       in

     

       150
       -
       stdenvNoCC.mkDerivation (args // {

     

       151
        
         dotnetInstallPath = installPath;

     

       152
        
         dotnetExecutables = executables;

     

       153
        
         dotnetBuildType = buildType;

     

       154
        
         dotnetProjectFiles = projectFiles;

     

       155
        
         dotnetTestProjectFiles = testProjectFiles;

     

       156
        
         dotnetDisabledTests = disabledTests;

     

       157
       -
         dotnetRuntimeId = runtimeId;

     

       158
       -
         nugetSource = nuget-source;

     

       0
        
       
     

       0
        
       
     

       159
        
         dotnetRuntimeDeps = map lib.getLib runtimeDeps;

     

       160
        
         dotnetSelfContainedBuild = selfContainedBuild;

     

       161
        
         dotnetUseAppHost = useAppHost;

     
···

       171
        
           cacert

     

       172
        
           makeWrapper

     

       173
        
           dotnet-sdk

     

       0
        
       
     

       0
        
       
     

       174
        
         ];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       175
        
       

     

       176
        
         # Parse the version attr into a format acceptable for the Version msbuild property

     

       177
        
         # The actual version attr is saved in InformationalVersion, which accepts an arbitrary string

     
···

       204
        
         propagatedSandboxProfile = toString dotnet-runtime.__propagatedSandboxProfile;

     

       205
        
       

     

       206
        
         passthru = {

     

       207
       -
           inherit nuget-source;

     

       208
        
         } // lib.optionalAttrs (!lib.isDerivation nugetDeps) {

     

       209
        
           fetch-deps = let

     

       210
       -
             flagsList = dotnetFlags ++ dotnetRestoreFlags;

     

       211
       -
             flags = lib.concatStringsSep " " (map lib.escapeShellArg flagsList);

     

       212
       -
             disableParallel =

     

       213
       -
               lib.optionalString (!enableParallelBuilding) "--disable-parallel";

     

       214
       -
             runtimeIdsList = if runtimeId != null then

     

       215
       -
               [ runtimeId ]

     

       216
       -
             else

     

       217
       -
               map (system: dotnetCorePackages.systemToDotnetRid system) platforms;

     

       218
       -
             runtimeIds =

     

       219
       -
               lib.concatStringsSep " " (map lib.escapeShellArg runtimeIdsList);

     

       220
       -
             defaultDepsFile =

     

       221
       -
               # Wire in the nugetDeps file such that running the script with no args

     

       222
       -
               # runs it agains the correct deps file by default.

     

       223
       -
               # Note that toString is necessary here as it results in the path at

     

       224
       -
               # eval time (i.e. to the file in your local Nixpkgs checkout) rather

     

       225
       -
               # than the Nix store path of the path after it's been imported.

     

       226
       -
               if lib.isPath nugetDepsFile

     

       227
       -
               && !lib.hasPrefix "${builtins.storeDir}/" (toString nugetDepsFile) then

     

       228
       -
                 toString nugetDepsFile

     

       229
       -
               else

     

       230
       -
                 ''$(mktemp -t "${pname}-deps-XXXXXX.nix")'';

     

       231
       -
             storeSrc = srcOnly args;

     

       232
       -
             projectFileStr = lib.escapeShellArgs projectFiles;

     

       233
       -
             testProjectFileStr = lib.escapeShellArgs testProjectFiles;

     

       234
       -
             path = lib.makeBinPath [

     

       235
       -
               coreutils

     

       236
       -
               runtimeShellPackage

     

       237
       -
               dotnet-sdk

     

       238
       -
               (nuget-to-nix.override { inherit dotnet-sdk; })

     

       239
       -
             ];

     

       240
       -
             dotnetSdkPath = toString dotnet-sdk;

     

       241
       -
             excludedSources =

     

       242
       -
               lib.concatStringsSep " " (map lib.escapeShellArg sdkDeps);

     

       243
       -
           in substituteAll {

     

       244
       -
             name = "fetch-deps";

     

       245
       -
             src = ./fetch-deps.sh;

     

       246
       -
             isExecutable = true;

     

       247
       -
             inherit pname defaultDepsFile runtimeIds storeSrc flags disableParallel

     

       248
       -
             projectFileStr testProjectFileStr path dotnetSdkPath excludedSources

     

       249
       -
             runtimeShell;

     

       250
       -
           };

     

       251
        
         } // args.passthru or { };

     

       252
        
       

     

       253
        
         meta = (args.meta or { }) // { inherit platforms; };

···

       4
        
       , callPackage

     

       5
        
       , substituteAll

     

       6
        
       , writeShellScript

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       7
        
       , makeWrapper

     

       8
        
       , dotnetCorePackages

     

       0
        
       
     

       9
        
       , mkNugetDeps

     

       10
        
       , nuget-to-nix

     

       11
        
       , cacert

     

       12
       +
       , unzip

     

       13
       +
       , yq

     

       14
       +
       , nix

     

       15
        
       }:

     

       16
        
       

     

       17
        
       { name ? "${_args.pname}-${_args.version}"

     
···

       103
        
           inherit dotnet-sdk dotnet-runtime;

     

       104
        
         }) dotnetConfigureHook dotnetBuildHook dotnetCheckHook dotnetInstallHook dotnetFixupHook;

     

       105
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       106
        
         _nugetDeps =

     

       107
        
           if (nugetDeps != null) then

     

       108
        
             if lib.isDerivation nugetDeps

     
···

       113
        
             }

     

       114
        
           else throw "Defining the `nugetDeps` attribute is required, as to lock the NuGet dependencies. This file can be generated by running the `passthru.fetch-deps` script.";

     

       115
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       116
        
         nugetDepsFile = _nugetDeps.sourceFile;

     

       117
       +
       

     

       118
       +
         inherit (dotnetCorePackages) systemToDotnetRid;

     

       119
        
       in

     

       120
       +
       stdenvNoCC.mkDerivation (finalAttrs: args // {

     

       121
        
         dotnetInstallPath = installPath;

     

       122
        
         dotnetExecutables = executables;

     

       123
        
         dotnetBuildType = buildType;

     

       124
        
         dotnetProjectFiles = projectFiles;

     

       125
        
         dotnetTestProjectFiles = testProjectFiles;

     

       126
        
         dotnetDisabledTests = disabledTests;

     

       127
       +
         dotnetRuntimeIds = lib.singleton (

     

       128
       +
           if runtimeId != null

     

       129
       +
           then runtimeId

     

       130
       +
           else systemToDotnetRid stdenvNoCC.hostPlatform.system);

     

       131
        
         dotnetRuntimeDeps = map lib.getLib runtimeDeps;

     

       132
        
         dotnetSelfContainedBuild = selfContainedBuild;

     

       133
        
         dotnetUseAppHost = useAppHost;

     
···

       143
        
           cacert

     

       144
        
           makeWrapper

     

       145
        
           dotnet-sdk

     

       146
       +
           unzip

     

       147
       +
           yq

     

       148
        
         ];

     

       149
       +
       

     

       150
       +
         buildInputs = args.buildInputs or [] ++ [

     

       151
       +
           dotnet-sdk.packages

     

       152
       +
           _nugetDeps

     

       153
       +
         ] ++ projectReferences;

     

       154
        
       

     

       155
        
         # Parse the version attr into a format acceptable for the Version msbuild property

     

       156
        
         # The actual version attr is saved in InformationalVersion, which accepts an arbitrary string

     
···

       183
        
         propagatedSandboxProfile = toString dotnet-runtime.__propagatedSandboxProfile;

     

       184
        
       

     

       185
        
         passthru = {

     

       186
       +
           nugetDeps = _nugetDeps;

     

       187
        
         } // lib.optionalAttrs (!lib.isDerivation nugetDeps) {

     

       188
        
           fetch-deps = let

     

       189
       +
             pkg = finalAttrs.finalPackage.overrideAttrs (old: {

     

       190
       +
               buildInputs = lib.remove _nugetDeps old.buildInputs;

     

       191
       +
               keepNugetConfig = true;

     

       192
       +
             } // lib.optionalAttrs (runtimeId == null) {

     

       193
       +
               dotnetRuntimeIds = map (system: systemToDotnetRid system) platforms;

     

       194
       +
             });

     

       195
       +
       

     

       196
       +
             drv = builtins.unsafeDiscardOutputDependency pkg.drvPath;

     

       197
       +
       

     

       198
       +
             innerScript = substituteAll {

     

       199
       +
               src = ./fetch-deps.sh;

     

       200
       +
               isExecutable = true;

     

       201
       +
               defaultDepsFile =

     

       202
       +
                 # Wire in the nugetDeps file such that running the script with no args

     

       203
       +
                 # runs it agains the correct deps file by default.

     

       204
       +
                 # Note that toString is necessary here as it results in the path at

     

       205
       +
                 # eval time (i.e. to the file in your local Nixpkgs checkout) rather

     

       206
       +
                 # than the Nix store path of the path after it's been imported.

     

       207
       +
                 if lib.isPath nugetDepsFile

     

       208
       +
                 && !lib.hasPrefix "${builtins.storeDir}/" (toString nugetDepsFile) then

     

       209
       +
                   toString nugetDepsFile

     

       210
       +
                 else

     

       211
       +
                   ''$(mktemp -t "${pname}-deps-XXXXXX.nix")'';

     

       212
       +
               nugetToNix = (nuget-to-nix.override { inherit dotnet-sdk; });

     

       213
       +
             };

     

       214
       +
       

     

       215
       +
             in writeShellScript "${name}-fetch-deps" ''

     

       216
       +
               NIX_BUILD_SHELL="${runtimeShell}" exec ${nix}/bin/nix-shell \

     

       217
       +
                 --pure --run 'source "${innerScript}"' "${drv}"

     

       218
       +
             '';

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       219
        
         } // args.passthru or { };

     

       220
        
       

     

       221
        
         meta = (args.meta or { }) // { inherit platforms; };

+13 -102

pkgs/build-support/dotnet/build-dotnet-module/fetch-deps.sh

···

       1
       -
       #! @runtimeShell@

     

       2
       -
       # shellcheck shell=bash

     

       3
       -
       set -euo pipefail

     

       4
       -
       

     

       5
       -
       export PATH="@path@"

     

       6
       -
       

     

       7
       -
       for arg in "$@"; do

     

       8
       -
           case "$arg" in

     

       9
       -
               --keep-sources|-k)

     

       10
       -
                   keepSources=1

     

       11
       -
                   shift

     

       12
       -
                   ;;

     

       13
       -
               --help|-h)

     

       14
       -
                   echo "usage: $0 [--keep-sources] [--help] <output path>"

     

       15
       -
                   echo "    <output path>   The path to write the lockfile to. A temporary file is used if this is not set"

     

       16
       -
                   echo "    --keep-sources  Dont remove temporary directories upon exit, useful for debugging"

     

       17
       -
                   echo "    --help          Show this help message"

     

       18
       -
                   exit

     

       19
       -
                   ;;

     

       20
       -
           esac

     

       21
       -
       done

     

       22
       -
       

     

       23
       -
       if [[ ${TMPDIR:-} == /run/user/* ]]; then

     

       24
       -
          # /run/user is usually a tmpfs in RAM, which may be too small

     

       25
       -
          # to store all downloaded dotnet packages

     

       26
       -
          unset TMPDIR

     

       27
       -
       fi

     

       28
       -
       

     

       29
       -
       export tmp=$(mktemp -td "deps-@pname@-XXXXXX")

     

       30
       -
       HOME=$tmp/home

     

       31
        
       

     

       32
       -
       exitTrap() {

     

       33
       -
           test -n "${ranTrap-}" && return

     

       34
       -
           ranTrap=1

     

       35
        
       

     

       36
       -
           if test -n "${keepSources-}"; then

     

       37
       -
               echo -e "Path to the source: $tmp/src\nPath to the fake home: $tmp/home"

     

       38
       -
           else

     

       39
       -
               rm -rf "$tmp"

     

       40
       -
           fi

     

       41
        
       

     

       42
       -
           # Since mktemp is used this will be empty if the script didnt succesfully complete

     

       43
       -
           if ! test -s "$depsFile"; then

     

       44
       -
             rm -rf "$depsFile"

     

       45
       -
           fi

     

       46
       -
       }

     

       47
       -
       

     

       48
       -
       trap exitTrap EXIT INT TERM

     

       49
       -
       

     

       50
       -
       dotnetRestore() {

     

       51
       -
           local -r project="${1-}"

     

       52
       -
           local -r rid="$2"

     

       53
       -
       

     

       54
       -
           dotnet restore ${project-} \

     

       55
       -
               -p:ContinuousIntegrationBuild=true \

     

       56
       -
               -p:Deterministic=true \

     

       57
       -
               --packages "$tmp/nuget_pkgs" \

     

       58
       -
               --runtime "$rid" \

     

       59
       -
               --no-cache \

     

       60
       -
               --force \

     

       61
       -
               @disableParallel@ \

     

       62
       -
               @flags@

     

       63
       -
       }

     

       64
       -
       

     

       65
       -
       declare -a projectFiles=( @projectFileStr@ )

     

       66
       -
       declare -a testProjectFiles=( @testProjectFileStr@ )

     

       67
       -
       

     

       68
       -
       export DOTNET_NOLOGO=1

     

       69
       -
       export DOTNET_CLI_TELEMETRY_OPTOUT=1

     

       70
        
       

     

       71
        
       depsFile=$(realpath "${1:-@defaultDepsFile@}")

     

       72
       -
       echo Will write lockfile to "$depsFile"

     

       73
       -
       mkdir -p "$tmp/nuget_pkgs"

     

       74
       -
       

     

       75
       -
       storeSrc="@storeSrc@"

     

       76
       -
       src=$tmp/src

     

       77
       -
       cp -rT "$storeSrc" "$src"

     

       78
       -
       chmod -R +w "$src"

     

       79
       -
       

     

       80
       -
       cd "$src"

     

       81
       -
       echo "Restoring project..."

     

       82
       -
       

     

       83
       -
       "@dotnetSdkPath@/bin/dotnet" tool restore

     

       84
       -
       cp -r $HOME/.nuget/packages/* $tmp/nuget_pkgs || true

     

       85
       -
       

     

       86
       -
       runtimeIds=(@runtimeIds@)

     

       87
       -
       

     

       88
       -
       for rid in "${runtimeIds[@]}"; do

     

       89
       -
           (( ${#projectFiles[@]} == 0 )) && dotnetRestore "" "$rid"

     

       90
       -
       

     

       91
       -
           for project in ${projectFiles[@]-} ${testProjectFiles[@]-}; do

     

       92
       -
               dotnetRestore "$project" "$rid"

     

       93
       -
           done

     

       94
       -
       done

     

       95
       -
       # Second copy, makes sure packages restored by ie. paket are included

     

       96
       -
       cp -r $HOME/.nuget/packages/* $tmp/nuget_pkgs || true

     

       97
       -
       

     

       98
       -
       echo "Succesfully restored project"

     

       99
       -
       

     

       100
       -
       echo "Writing lockfile..."

     

       101
       -
       

     

       102
       -
       excluded_sources=( @excludedSources@ )

     

       103
       -
       for excluded_source in ${excluded_sources[@]}; do

     

       104
       -
         ls "$excluded_source" >> "$tmp/excluded_list"

     

       105
       -
       done

     

       106
        
       tmpFile="$tmp"/deps.nix

     

       107
        
       echo -e "# This file was automatically generated by passthru.fetch-deps.\n# Please dont edit it manually, your changes might get overwritten!\n" > "$tmpFile"

     

       108
       -
       nuget-to-nix "$tmp/nuget_pkgs" "$tmp/excluded_list" >> "$tmpFile"

     

       109
        
       mv "$tmpFile" "$depsFile"

     

       110
        
       echo "Succesfully wrote lockfile to $depsFile"

     

       111
       -

···

       1
       +
       set -e

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2
        
       

     

       3
       +
       tmp=$(mktemp -d)

     

       4
       +
       trap 'chmod -R +w "$tmp" && rm -fr "$tmp"' EXIT

     

       0
        
       
     

       5
        
       

     

       6
       +
       HOME=$tmp/.home

     

       7
       +
       cd "$tmp"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       8
        
       

     

       9
       +
       phases="

     

       10
       +
           ${prePhases[*]:-}

     

       11
       +
           unpackPhase

     

       12
       +
           patchPhase

     

       13
       +
           ${preConfigurePhases[*]:-}

     

       14
       +
           configurePhase

     

       15
       +
       " genericBuild

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       16
        
       

     

       17
        
       depsFile=$(realpath "${1:-@defaultDepsFile@}")

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       18
        
       tmpFile="$tmp"/deps.nix

     

       19
        
       echo -e "# This file was automatically generated by passthru.fetch-deps.\n# Please dont edit it manually, your changes might get overwritten!\n" > "$tmpFile"

     

       20
       +
       @nugetToNix@/bin/nuget-to-nix "$NUGET_PACKAGES" >> "$tmpFile"

     

       21
        
       mv "$tmpFile" "$depsFile"

     

       22
        
       echo "Succesfully wrote lockfile to $depsFile"

     

       0

+2 -12

pkgs/build-support/dotnet/build-dotnet-module/hooks/default.nix

···

       5
        
       , zlib

     

       6
        
       , openssl

     

       7
        
       , makeSetupHook

     

       8
       -
       , dotnetCorePackages

     

       9
        
         # Passed from ../default.nix

     

       10
        
       , dotnet-sdk

     

       11
        
       , dotnet-runtime

     

       12
        
       }:

     

       13
       -
       let

     

       14
       -
         runtimeId = dotnetCorePackages.systemToDotnetRid stdenv.hostPlatform.system;

     

       15
       -
       in

     

       16
        
       {

     

       17
        
         dotnetConfigureHook = makeSetupHook

     

       18
        
           {

     

       19
        
             name = "dotnet-configure-hook";

     

       20
        
             substitutions = {

     

       21
       -
               runtimeId = lib.escapeShellArg runtimeId;

     

       22
        
               dynamicLinker = "${stdenv.cc}/nix-support/dynamic-linker";

     

       23
        
               libPath = lib.makeLibraryPath [

     

       24
        
                 stdenv.cc.cc.lib

     
···

       34
        
         dotnetBuildHook = makeSetupHook

     

       35
        
           {

     

       36
        
             name = "dotnet-build-hook";

     

       37
       -
             substitutions = {

     

       38
       -
               runtimeId = lib.escapeShellArg runtimeId;

     

       39
       -
             };

     

       40
        
           }

     

       41
        
           ./dotnet-build-hook.sh;

     

       42
        
       

     

       43
        
         dotnetCheckHook = makeSetupHook

     

       44
        
           {

     

       45
        
             name = "dotnet-check-hook";

     

       46
       -
             substitutions = {

     

       47
       -
               runtimeId = lib.escapeShellArg runtimeId;

     

       48
       -
             };

     

       49
        
           }

     

       50
        
           ./dotnet-check-hook.sh;

     

       51
        
       

     
···

       53
        
           {

     

       54
        
             name = "dotnet-install-hook";

     

       55
        
             substitutions = {

     

       56
       -
               runtimeId = lib.escapeShellArg runtimeId;

     

       57
        
             };

     

       58
        
           }

     

       59
        
           ./dotnet-install-hook.sh;

···

       5
        
       , zlib

     

       6
        
       , openssl

     

       7
        
       , makeSetupHook

     

       8
       +
       , zip

     

       9
        
         # Passed from ../default.nix

     

       10
        
       , dotnet-sdk

     

       11
        
       , dotnet-runtime

     

       12
        
       }:

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       13
        
       {

     

       14
        
         dotnetConfigureHook = makeSetupHook

     

       15
        
           {

     

       16
        
             name = "dotnet-configure-hook";

     

       17
        
             substitutions = {

     

       0
        
       
     

       18
        
               dynamicLinker = "${stdenv.cc}/nix-support/dynamic-linker";

     

       19
        
               libPath = lib.makeLibraryPath [

     

       20
        
                 stdenv.cc.cc.lib

     
···

       30
        
         dotnetBuildHook = makeSetupHook

     

       31
        
           {

     

       32
        
             name = "dotnet-build-hook";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       33
        
           }

     

       34
        
           ./dotnet-build-hook.sh;

     

       35
        
       

     

       36
        
         dotnetCheckHook = makeSetupHook

     

       37
        
           {

     

       38
        
             name = "dotnet-check-hook";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       39
        
           }

     

       40
        
           ./dotnet-check-hook.sh;

     

       41
        
       

     
···

       43
        
           {

     

       44
        
             name = "dotnet-install-hook";

     

       45
        
             substitutions = {

     

       46
       +
               inherit zip;

     

       47
        
             };

     

       48
        
           }

     

       49
        
           ./dotnet-install-hook.sh;

+20 -17

pkgs/build-support/dotnet/build-dotnet-module/hooks/dotnet-build-hook.sh

···

       3
        
       

     

       4
        
           runHook preBuild

     

       5
        
       

     

       6
       -
           local -r hostRuntimeId=@runtimeId@

     

       7
        
           local -r dotnetBuildType="${dotnetBuildType-Release}"

     

       8
       -
           local -r dotnetRuntimeId="${dotnetRuntimeId-$hostRuntimeId}"

     

       9
        
       

     

       10
        
           if [[ -n $__structuredAttrs ]]; then

     

       11
        
               local dotnetProjectFilesArray=( "${dotnetProjectFiles[@]}" )

     

       12
        
               local dotnetTestProjectFilesArray=( "${dotnetTestProjectFiles[@]}" )

     

       13
        
               local dotnetFlagsArray=( "${dotnetFlags[@]}" )

     

       14
        
               local dotnetBuildFlagsArray=( "${dotnetBuildFlags[@]}" )

     

       0
        
       
     

       15
        
           else

     

       16
        
               local dotnetProjectFilesArray=($dotnetProjectFiles)

     

       17
        
               local dotnetTestProjectFilesArray=($dotnetTestProjectFiles)

     

       18
        
               local dotnetFlagsArray=($dotnetFlags)

     

       19
        
               local dotnetBuildFlagsArray=($dotnetBuildFlags)

     

       0
        
       
     

       20
        
           fi

     

       21
        
       

     

       22
        
           if [[ -n "${enableParallelBuilding-}" ]]; then

     
···

       49
        
           dotnetBuild() {

     

       50
        
               local -r projectFile="${1-}"

     

       51
        
       

     

       52
       -
               local runtimeIdFlagsArray=()

     

       53
       -
               if [[ $projectFile == *.csproj || -n ${dotnetSelfContainedBuild-} ]]; then

     

       54
       -
                   runtimeIdFlagsArray+=("--runtime" "$dotnetRuntimeId")

     

       55
       -
               fi

     

       0
        
       
     

       56
        
       

     

       57
       -
               dotnet build ${1+"$projectFile"} \

     

       58
       -
                   -maxcpucount:"$maxCpuFlag" \

     

       59
       -
                   -p:BuildInParallel="$parallelBuildFlag" \

     

       60
       -
                   -p:ContinuousIntegrationBuild=true \

     

       61
       -
                   -p:Deterministic=true \

     

       62
       -
                   --configuration "$dotnetBuildType" \

     

       63
       -
                   --no-restore \

     

       64
       -
                   "${versionFlagsArray[@]}" \

     

       65
       -
                   "${runtimeIdFlagsArray[@]}" \

     

       66
       -
                   "${dotnetBuildFlagsArray[@]}" \

     

       67
       -
                   "${dotnetFlagsArray[@]}"

     

       0
        
       
     

       0
        
       
     

       68
        
           }

     

       69
        
       

     

       70
        
           if (( ${#dotnetProjectFilesArray[@]} == 0 )); then

···

       3
        
       

     

       4
        
           runHook preBuild

     

       5
        
       

     

       0
        
       
     

       6
        
           local -r dotnetBuildType="${dotnetBuildType-Release}"

     

       0
        
       
     

       7
        
       

     

       8
        
           if [[ -n $__structuredAttrs ]]; then

     

       9
        
               local dotnetProjectFilesArray=( "${dotnetProjectFiles[@]}" )

     

       10
        
               local dotnetTestProjectFilesArray=( "${dotnetTestProjectFiles[@]}" )

     

       11
        
               local dotnetFlagsArray=( "${dotnetFlags[@]}" )

     

       12
        
               local dotnetBuildFlagsArray=( "${dotnetBuildFlags[@]}" )

     

       13
       +
               local dotnetRuntimeIdsArray=( "${dotnetRuntimeIds[@]}" )

     

       14
        
           else

     

       15
        
               local dotnetProjectFilesArray=($dotnetProjectFiles)

     

       16
        
               local dotnetTestProjectFilesArray=($dotnetTestProjectFiles)

     

       17
        
               local dotnetFlagsArray=($dotnetFlags)

     

       18
        
               local dotnetBuildFlagsArray=($dotnetBuildFlags)

     

       19
       +
               local dotnetRuntimeIdsArray=($dotnetRuntimeIds)

     

       20
        
           fi

     

       21
        
       

     

       22
        
           if [[ -n "${enableParallelBuilding-}" ]]; then

     
···

       49
        
           dotnetBuild() {

     

       50
        
               local -r projectFile="${1-}"

     

       51
        
       

     

       52
       +
               for runtimeId in "${dotnetRuntimeIdsArray[@]}"; do

     

       53
       +
                   local runtimeIdFlagsArray=()

     

       54
       +
                   if [[ $projectFile == *.csproj || -n ${dotnetSelfContainedBuild-} ]]; then

     

       55
       +
                       runtimeIdFlagsArray+=("--runtime" "$runtimeId")

     

       56
       +
                   fi

     

       57
        
       

     

       58
       +
                   dotnet build ${1+"$projectFile"} \

     

       59
       +
                       -maxcpucount:"$maxCpuFlag" \

     

       60
       +
                       -p:BuildInParallel="$parallelBuildFlag" \

     

       61
       +
                       -p:ContinuousIntegrationBuild=true \

     

       62
       +
                       -p:Deterministic=true \

     

       63
       +
                       -p:OverwriteReadOnlyFiles=true \

     

       64
       +
                       --configuration "$dotnetBuildType" \

     

       65
       +
                       --no-restore \

     

       66
       +
                       "${versionFlagsArray[@]}" \

     

       67
       +
                       "${runtimeIdFlagsArray[@]}" \

     

       68
       +
                       "${dotnetBuildFlagsArray[@]}" \

     

       69
       +
                       "${dotnetFlagsArray[@]}"

     

       70
       +
               done

     

       71
        
           }

     

       72
        
       

     

       73
        
           if (( ${#dotnetProjectFilesArray[@]} == 0 )); then

+20 -18

pkgs/build-support/dotnet/build-dotnet-module/hooks/dotnet-check-hook.sh

···

       3
        
       

     

       4
        
           runHook preCheck

     

       5
        
       

     

       6
       -
           local -r hostRuntimeId=@runtimeId@

     

       7
        
           local -r dotnetBuildType="${dotnetBuildType-Release}"

     

       8
       -
           local -r dotnetRuntimeId="${dotnetRuntimeId-$hostRuntimeId}"

     

       9
        
       

     

       10
        
           if [[ -n $__structuredAttrs ]]; then

     

       11
        
               local dotnetProjectFilesArray=( "${dotnetProjectFiles[@]}" )

     
···

       13
        
               local dotnetTestFlagsArray=( "${dotnetTestFlags[@]}" )

     

       14
        
               local dotnetDisabledTestsArray=( "${dotnetDisabledTests[@]}" )

     

       15
        
               local dotnetRuntimeDepsArray=( "${dotnetRuntimeDeps[@]}" )

     

       0
        
       
     

       16
        
           else

     

       17
        
               local dotnetProjectFilesArray=($dotnetProjectFiles)

     

       18
        
               local dotnetTestProjectFilesArray=($dotnetTestProjectFiles)

     

       19
        
               local dotnetTestFlagsArray=($dotnetTestFlags)

     

       20
        
               local dotnetDisabledTestsArray=($dotnetDisabledTests)

     

       21
        
               local dotnetRuntimeDepsArray=($dotnetRuntimeDeps)

     

       0
        
       
     

       22
        
           fi

     

       23
        
       

     

       24
        
           if (( ${#dotnetDisabledTestsArray[@]} > 0 )); then

     
···

       42
        
               local -r maxCpuFlag="1"

     

       43
        
           fi

     

       44
        
       

     

       45
       -
           local projectFile

     

       46
        
           for projectFile in "${dotnetTestProjectFilesArray[@]-${dotnetProjectFilesArray[@]}}"; do

     

       47
       -
               local runtimeIdFlagsArray=()

     

       48
       -
               if [[ $projectFile == *.csproj ]]; then

     

       49
       -
                   runtimeIdFlagsArray=("--runtime" "$dotnetRuntimeId")

     

       50
       -
               fi

     

       0
        
       
     

       51
        
       

     

       52
       -
               LD_LIBRARY_PATH=$libraryPath \

     

       53
       -
                   dotnet test "$projectFile" \

     

       54
       -
                     -maxcpucount:"$maxCpuFlag" \

     

       55
       -
                     -p:ContinuousIntegrationBuild=true \

     

       56
       -
                     -p:Deterministic=true \

     

       57
       -
                     --configuration "$dotnetBuildType" \

     

       58
       -
                     --no-build \

     

       59
       -
                     --logger "console;verbosity=normal" \

     

       60
       -
                     "${runtimeIdFlagsArray[@]}" \

     

       61
       -
                     "${dotnetTestFlagsArray[@]}" \

     

       62
       -
                     "${dotnetFlagsArray[@]}"

     

       0
        
       
     

       63
        
           done

     

       64
        
       

     

       65
        
           runHook postCheck

···

       3
        
       

     

       4
        
           runHook preCheck

     

       5
        
       

     

       0
        
       
     

       6
        
           local -r dotnetBuildType="${dotnetBuildType-Release}"

     

       0
        
       
     

       7
        
       

     

       8
        
           if [[ -n $__structuredAttrs ]]; then

     

       9
        
               local dotnetProjectFilesArray=( "${dotnetProjectFiles[@]}" )

     
···

       11
        
               local dotnetTestFlagsArray=( "${dotnetTestFlags[@]}" )

     

       12
        
               local dotnetDisabledTestsArray=( "${dotnetDisabledTests[@]}" )

     

       13
        
               local dotnetRuntimeDepsArray=( "${dotnetRuntimeDeps[@]}" )

     

       14
       +
               local dotnetRuntimeIdsArray=( "${dotnetRuntimeIds[@]}" )

     

       15
        
           else

     

       16
        
               local dotnetProjectFilesArray=($dotnetProjectFiles)

     

       17
        
               local dotnetTestProjectFilesArray=($dotnetTestProjectFiles)

     

       18
        
               local dotnetTestFlagsArray=($dotnetTestFlags)

     

       19
        
               local dotnetDisabledTestsArray=($dotnetDisabledTests)

     

       20
        
               local dotnetRuntimeDepsArray=($dotnetRuntimeDeps)

     

       21
       +
               local dotnetRuntimeIdsArray=($dotnetRuntimeIds)

     

       22
        
           fi

     

       23
        
       

     

       24
        
           if (( ${#dotnetDisabledTestsArray[@]} > 0 )); then

     
···

       42
        
               local -r maxCpuFlag="1"

     

       43
        
           fi

     

       44
        
       

     

       45
       +
           local projectFile runtimeId

     

       46
        
           for projectFile in "${dotnetTestProjectFilesArray[@]-${dotnetProjectFilesArray[@]}}"; do

     

       47
       +
               for runtimeId in "${dotnetRuntimeIdsArray[@]}"; do

     

       48
       +
                   local runtimeIdFlagsArray=()

     

       49
       +
                   if [[ $projectFile == *.csproj ]]; then

     

       50
       +
                       runtimeIdFlagsArray=("--runtime" "$runtimeId")

     

       51
       +
                   fi

     

       52
        
       

     

       53
       +
                   LD_LIBRARY_PATH=$libraryPath \

     

       54
       +
                       dotnet test "$projectFile" \

     

       55
       +
                       -maxcpucount:"$maxCpuFlag" \

     

       56
       +
                       -p:ContinuousIntegrationBuild=true \

     

       57
       +
                       -p:Deterministic=true \

     

       58
       +
                       --configuration "$dotnetBuildType" \

     

       59
       +
                       --no-build \

     

       60
       +
                       --logger "console;verbosity=normal" \

     

       61
       +
                       "${runtimeIdFlagsArray[@]}" \

     

       62
       +
                       "${dotnetTestFlagsArray[@]}" \

     

       63
       +
                       "${dotnetFlagsArray[@]}"

     

       64
       +
               done

     

       65
        
           done

     

       66
        
       

     

       67
        
           runHook postCheck

+26 -66

pkgs/build-support/dotnet/build-dotnet-module/hooks/dotnet-configure-hook.sh

···

       3
        
       

     

       4
        
           runHook preConfigure

     

       5
        
       

     

       6
       -
           if [[ -z ${nugetSource-} ]]; then

     

       7
       -
               echo

     

       8
       -
               echo "ERROR: no dependencies were specified"

     

       9
       -
               echo 'Hint: set `nugetSource` if using these hooks individually. If this is happening with `buildDotnetModule`, please open an issue.'

     

       10
       -
               echo

     

       11
       -
       

     

       12
       -
               exit 1

     

       13
       -
           fi

     

       14
       -
       

     

       15
       -
           local nugetSourceSedQuoted="${nugetSource//[\/\\&$'\n']/\\&}"

     

       16
       -
           local nugetSourceXMLQuoted="$nugetSource"

     

       17
       -
           nugetSourceXMLQuoted="${nugetSource//&/\&amp;}"

     

       18
       -
           nugetSourceXMLQuoted="${nugetSourceXMLQuoted//\"/\&quot;}"

     

       19
       -
       

     

       20
       -
           local -r hostRuntimeId=@runtimeId@

     

       21
        
           local -r dynamicLinker=@dynamicLinker@

     

       22
        
           local -r libPath=@libPath@

     

       23
       -
           local -r dotnetRuntimeId="${dotnetRuntimeId-$hostRuntimeId}"

     

       24
        
       

     

       25
        
           if [[ -n $__structuredAttrs ]]; then

     

       26
        
               local dotnetProjectFilesArray=( "${dotnetProjectFiles[@]}" )

     

       27
        
               local dotnetTestProjectFilesArray=( "${dotnetTestProjectFiles[@]}" )

     

       28
        
               local dotnetFlagsArray=( "${dotnetFlags[@]}" )

     

       29
        
               local dotnetRestoreFlagsArray=( "${dotnetRestoreFlags[@]}" )

     

       0
        
       
     

       30
        
           else

     

       31
        
               local dotnetProjectFilesArray=($dotnetProjectFiles)

     

       32
        
               local dotnetTestProjectFilesArray=($dotnetTestProjectFiles)

     

       33
        
               local dotnetFlagsArray=($dotnetFlags)

     

       34
        
               local dotnetRestoreFlagsArray=($dotnetRestoreFlags)

     

       0
        
       
     

       35
        
           fi

     

       36
        
       

     

       37
        
           if [[ -z ${enableParallelBuilding-} ]]; then

     
···

       40
        
       

     

       41
        
           dotnetRestore() {

     

       42
        
               local -r projectFile="${1-}"

     

       43
       -
               dotnet restore ${1+"$projectFile"} \

     

       44
       -
                   -p:ContinuousIntegrationBuild=true \

     

       45
       -
                   -p:Deterministic=true \

     

       46
       -
                   --runtime "$dotnetRuntimeId" \

     

       47
       -
                   --source "$nugetSource/lib" \

     

       48
       -
                   ${parallelFlag-} \

     

       49
       -
                   "${dotnetRestoreFlagsArray[@]}" \

     

       50
       -
                   "${dotnetFlagsArray[@]}"

     

       0
        
       
     

       0
        
       
     

       51
        
           }

     

       52
        
       

     

       53
       -
           # Generate a NuGet.config file to make sure everything,

     

       54
       -
           # including things like <Sdk /> dependencies, is restored from the proper source

     

       55
       -
           cat >NuGet.config <<EOF

     

       56
       -
       <?xml version="1.0" encoding="utf-8"?>

     

       57
       -
       <configuration>

     

       58
       -
         <packageSources>

     

       59
       -
           <clear />

     

       60
       -
           <add key="nugetSource" value="$nugetSourceXMLQuoted/lib" />

     

       61
       -
         </packageSources>

     

       62
       -
       </configuration>

     

       63
       -
       EOF

     

       64
        
       

     

       65
       -
           # Patch paket.dependencies and paket.lock (if found) to use the proper

     

       66
       -
           # source. This ensures paket restore works correctly. Note that the

     

       67
       -
           # nugetSourceSedQuoted abomination below safely escapes nugetSource string

     

       68
       -
           # for use as a sed replacement string to avoid issues with slashes and other

     

       69
       -
           # special characters ('&', '\\' and '\n').

     

       70
       -
           find -name paket.dependencies -exec sed -i "s/source .*/source $nugetSourceSedQuoted\/lib/g" {} \;

     

       71
       -
           find -name paket.lock -exec sed -i "s/remote:.*/remote: $nugetSourceSedQuoted\/lib/g" {} \;

     

       72
       -
       

     

       73
       -
           dotnet tool restore --add-source "$nugetSource/lib"

     

       74
        
       

     

       75
        
           # dotnetGlobalTool is set in buildDotnetGlobalTool to patch dependencies but

     

       76
        
           # avoid other project-specific logic. This is a hack, but the old behavior

     
···

       89
        
                   dotnetRestore "$projectFile"

     

       90
        
               done

     

       91
        
           fi

     

       92
       -
       

     

       93
       -
           echo "Fixing up native binaries..."

     

       94
       -
           # Find all native binaries and nuget libraries, and fix them up,

     

       95
       -
           # by setting the proper interpreter and rpath to some commonly used libraries

     

       96
       -
           local binary

     

       97
       -
           for binary in $(find "$HOME/.nuget/packages/" -type f -executable); do

     

       98
       -
               if patchelf --print-interpreter "$binary" >/dev/null 2>/dev/null; then

     

       99
       -
                   echo "Found binary: $binary, fixing it up..."

     

       100
       -
                   patchelf --set-interpreter "$(cat "$dynamicLinker")" "$binary"

     

       101
       -
       

     

       102
       -
                   # This makes sure that if the binary requires some specific runtime dependencies, it can find it.

     

       103
       -
                   # This fixes dotnet-built binaries like crossgen2

     

       104
       -
                   patchelf \

     

       105
       -
                       --add-needed libicui18n.so \

     

       106
       -
                       --add-needed libicuuc.so \

     

       107
       -
                       --add-needed libz.so \

     

       108
       -
                       --add-needed libssl.so \

     

       109
       -
                       "$binary"

     

       110
       -
       

     

       111
       -
                   patchelf --set-rpath "$libPath" "$binary"

     

       112
       -
               fi

     

       113
       -
           done

     

       114
        
       

     

       115
        
           runHook postConfigure

     

       116

···

       3
        
       

     

       4
        
           runHook preConfigure

     

       5
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       6
        
           local -r dynamicLinker=@dynamicLinker@

     

       7
        
           local -r libPath=@libPath@

     

       0
        
       
     

       8
        
       

     

       9
        
           if [[ -n $__structuredAttrs ]]; then

     

       10
        
               local dotnetProjectFilesArray=( "${dotnetProjectFiles[@]}" )

     

       11
        
               local dotnetTestProjectFilesArray=( "${dotnetTestProjectFiles[@]}" )

     

       12
        
               local dotnetFlagsArray=( "${dotnetFlags[@]}" )

     

       13
        
               local dotnetRestoreFlagsArray=( "${dotnetRestoreFlags[@]}" )

     

       14
       +
               local dotnetRuntimeIdsArray=( "${dotnetRuntimeIds[@]}" )

     

       15
        
           else

     

       16
        
               local dotnetProjectFilesArray=($dotnetProjectFiles)

     

       17
        
               local dotnetTestProjectFilesArray=($dotnetTestProjectFiles)

     

       18
        
               local dotnetFlagsArray=($dotnetFlags)

     

       19
        
               local dotnetRestoreFlagsArray=($dotnetRestoreFlags)

     

       20
       +
               local dotnetRuntimeIdsArray=($dotnetRuntimeIds)

     

       21
        
           fi

     

       22
        
       

     

       23
        
           if [[ -z ${enableParallelBuilding-} ]]; then

     
···

       26
        
       

     

       27
        
           dotnetRestore() {

     

       28
        
               local -r projectFile="${1-}"

     

       29
       +
               for runtimeId in "${dotnetRuntimeIdsArray[@]}"; do

     

       30
       +
                   dotnet restore ${1+"$projectFile"} \

     

       31
       +
                       -p:ContinuousIntegrationBuild=true \

     

       32
       +
                       -p:Deterministic=true \

     

       33
       +
                       -p:NuGetAudit=false \

     

       34
       +
                       --runtime "$runtimeId" \

     

       35
       +
                       ${parallelFlag-} \

     

       36
       +
                       "${dotnetRestoreFlagsArray[@]}" \

     

       37
       +
                       "${dotnetFlagsArray[@]}"

     

       38
       +
               done

     

       39
        
           }

     

       40
        
       

     

       41
       +
           find -iname nuget.config -print0 | while IFS= read -rd "" config; do

     

       42
       +
               if [[ -n "${keepNugetConfig-}" ]]; then

     

       43
       +
                   # If we're keeping the existing configs, we'll add _nix everywhere,

     

       44
       +
                   # in case sources are cleared.

     

       45
       +
                   dotnet nuget add source "$nugetSource" -n _nix --configfile "$config"

     

       46
       +
               else

     

       47
       +
                   # This will allow everything to fall through to our config in the

     

       48
       +
                   # build root. Deleting them causes some build failures.

     

       49
       +
                   xq -xi '.configuration={}' "$config"

     

       50
       +
               fi

     

       51
       +
           done

     

       52
        
       

     

       53
       +
           if [[ -f .config/dotnet-tools.json || -f .dotnet-tools.json ]]; then

     

       54
       +
               dotnet tool restore

     

       55
       +
           fi

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       56
        
       

     

       57
        
           # dotnetGlobalTool is set in buildDotnetGlobalTool to patch dependencies but

     

       58
        
           # avoid other project-specific logic. This is a hack, but the old behavior

     
···

       71
        
                   dotnetRestore "$projectFile"

     

       72
        
               done

     

       73
        
           fi

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       74
        
       

     

       75
        
           runHook postConfigure

     

       76

+55 -24

pkgs/build-support/dotnet/build-dotnet-module/hooks/dotnet-install-hook.sh

···

       3
        
       

     

       4
        
           runHook preInstall

     

       5
        
       

     

       6
       -
           local -r hostRuntimeId=@runtimeId@

     

       7
        
           local -r dotnetInstallPath="${dotnetInstallPath-$out/lib/$pname}"

     

       8
        
           local -r dotnetBuildType="${dotnetBuildType-Release}"

     

       9
       -
           local -r dotnetRuntimeId="${dotnetRuntimeId-$hostRuntimeId}"

     

       10
        
       

     

       11
        
           if [[ -n $__structuredAttrs ]]; then

     

       12
        
               local dotnetProjectFilesArray=( "${dotnetProjectFiles[@]}" )

     

       13
        
               local dotnetFlagsArray=( "${dotnetFlags[@]}" )

     

       14
        
               local dotnetInstallFlagsArray=( "${dotnetInstallFlags[@]}" )

     

       15
        
               local dotnetPackFlagsArray=( "${dotnetPackFlags[@]}" )

     

       0
        
       
     

       16
        
           else

     

       17
        
               local dotnetProjectFilesArray=($dotnetProjectFiles)

     

       18
        
               local dotnetFlagsArray=($dotnetFlags)

     

       19
        
               local dotnetInstallFlagsArray=($dotnetInstallFlags)

     

       20
        
               local dotnetPackFlagsArray=($dotnetPackFlags)

     

       0
        
       
     

       21
        
           fi

     

       22
        
       

     

       23
        
           if [[ -n ${dotnetSelfContainedBuild-} ]]; then

     
···

       31
        
       

     

       32
        
           if [[ -n ${dotnetUseAppHost-} ]]; then

     

       33
        
               dotnetInstallFlagsArray+=("-p:UseAppHost=true")

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       34
        
           fi

     

       35
        
       

     

       36
        
           dotnetPublish() {

     

       37
        
               local -r projectFile="${1-}"

     

       38
        
       

     

       39
       -
               runtimeIdFlagsArray=()

     

       40
       -
               if [[ $projectFile == *.csproj || -n ${dotnetSelfContainedBuild-} ]]; then

     

       41
       -
                   runtimeIdFlagsArray+=("--runtime" "$dotnetRuntimeId")

     

       42
       -
               fi

     

       0
        
       
     

       43
        
       

     

       44
       -
               dotnet publish ${1+"$projectFile"} \

     

       45
       -
                   -p:ContinuousIntegrationBuild=true \

     

       46
       -
                   -p:Deterministic=true \

     

       47
       -
                   --output "$dotnetInstallPath" \

     

       48
       -
                   --configuration "$dotnetBuildType" \

     

       49
       -
                   --no-build \

     

       50
       -
                   "${runtimeIdFlagsArray[@]}" \

     

       51
       -
                   "${dotnetInstallFlagsArray[@]}" \

     

       52
       -
                   "${dotnetFlagsArray[@]}"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       53
        
           }

     

       54
        
       

     

       0
        
       
     

       0
        
       
     

       55
        
           dotnetPack() {

     

       56
        
               local -r projectFile="${1-}"

     

       57
       -
               dotnet pack ${1+"$projectFile"} \

     

       58
       -
                   -p:ContinuousIntegrationBuild=true \

     

       59
       -
                   -p:Deterministic=true \

     

       60
       -
                   --output "$out/share" \

     

       61
       -
                   --configuration "$dotnetBuildType" \

     

       62
       -
                   --no-build \

     

       63
       -
                   --runtime "$dotnetRuntimeId" \

     

       64
       -
                   "${dotnetPackFlagsArray[@]}" \

     

       65
       -
                   "${dotnetFlagsArray[@]}"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       66
        
           }

     

       67
        
       

     

       68
        
           if (( ${#dotnetProjectFilesArray[@]} == 0 )); then

     
···

       84
        
                   done

     

       85
        
               fi

     

       86
        
           fi

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       87
        
       

     

       88
        
           runHook postInstall

     

       89

···

       3
        
       

     

       4
        
           runHook preInstall

     

       5
        
       

     

       0
        
       
     

       6
        
           local -r dotnetInstallPath="${dotnetInstallPath-$out/lib/$pname}"

     

       7
        
           local -r dotnetBuildType="${dotnetBuildType-Release}"

     

       0
        
       
     

       8
        
       

     

       9
        
           if [[ -n $__structuredAttrs ]]; then

     

       10
        
               local dotnetProjectFilesArray=( "${dotnetProjectFiles[@]}" )

     

       11
        
               local dotnetFlagsArray=( "${dotnetFlags[@]}" )

     

       12
        
               local dotnetInstallFlagsArray=( "${dotnetInstallFlags[@]}" )

     

       13
        
               local dotnetPackFlagsArray=( "${dotnetPackFlags[@]}" )

     

       14
       +
               local dotnetRuntimeIdsArray=( "${dotnetRuntimeIds[@]}" )

     

       15
        
           else

     

       16
        
               local dotnetProjectFilesArray=($dotnetProjectFiles)

     

       17
        
               local dotnetFlagsArray=($dotnetFlags)

     

       18
        
               local dotnetInstallFlagsArray=($dotnetInstallFlags)

     

       19
        
               local dotnetPackFlagsArray=($dotnetPackFlags)

     

       20
       +
               local dotnetRuntimeIdsArray=($dotnetRuntimeIds)

     

       21
        
           fi

     

       22
        
       

     

       23
        
           if [[ -n ${dotnetSelfContainedBuild-} ]]; then

     
···

       31
        
       

     

       32
        
           if [[ -n ${dotnetUseAppHost-} ]]; then

     

       33
        
               dotnetInstallFlagsArray+=("-p:UseAppHost=true")

     

       34
       +
           fi

     

       35
       +
       

     

       36
       +
           if [[ -n ${enableParallelBuilding-} ]]; then

     

       37
       +
               local -r maxCpuFlag="$NIX_BUILD_CORES"

     

       38
       +
           else

     

       39
       +
               local -r maxCpuFlag="1"

     

       40
        
           fi

     

       41
        
       

     

       42
        
           dotnetPublish() {

     

       43
        
               local -r projectFile="${1-}"

     

       44
        
       

     

       45
       +
               for runtimeId in "${dotnetRuntimeIdsArray[@]}"; do

     

       46
       +
                   runtimeIdFlagsArray=()

     

       47
       +
                   if [[ $projectFile == *.csproj || -n ${dotnetSelfContainedBuild-} ]]; then

     

       48
       +
                       runtimeIdFlagsArray+=("--runtime" "$runtimeId")

     

       49
       +
                   fi

     

       50
        
       

     

       51
       +
                   dotnet publish ${1+"$projectFile"} \

     

       52
       +
                       -maxcpucount:"$maxCpuFlag" \

     

       53
       +
                       -p:ContinuousIntegrationBuild=true \

     

       54
       +
                       -p:Deterministic=true \

     

       55
       +
                       -p:OverwriteReadOnlyFiles=true \

     

       56
       +
                       --output "$dotnetInstallPath" \

     

       57
       +
                       --configuration "$dotnetBuildType" \

     

       58
       +
                       --no-build \

     

       59
       +
                       "${runtimeIdFlagsArray[@]}" \

     

       60
       +
                       "${dotnetInstallFlagsArray[@]}" \

     

       61
       +
                       "${dotnetFlagsArray[@]}"

     

       62
       +
               done

     

       63
        
           }

     

       64
        
       

     

       65
       +
           local -r pkgs=$PWD/.nuget-pack

     

       66
       +
       

     

       67
        
           dotnetPack() {

     

       68
        
               local -r projectFile="${1-}"

     

       69
       +
       

     

       70
       +
               for runtimeId in "${dotnetRuntimeIdsArray[@]}"; do

     

       71
       +
                   dotnet pack ${1+"$projectFile"} \

     

       72
       +
                          -maxcpucount:"$maxCpuFlag" \

     

       73
       +
                          -p:ContinuousIntegrationBuild=true \

     

       74
       +
                          -p:Deterministic=true \

     

       75
       +
                          -p:OverwriteReadOnlyFiles=true \

     

       76
       +
                          --output "$pkgs" \

     

       77
       +
                          --configuration "$dotnetBuildType" \

     

       78
       +
                          --no-build \

     

       79
       +
                          --runtime "$runtimeId" \

     

       80
       +
                          "${dotnetPackFlagsArray[@]}" \

     

       81
       +
                          "${dotnetFlagsArray[@]}"

     

       82
       +
               done

     

       83
        
           }

     

       84
        
       

     

       85
        
           if (( ${#dotnetProjectFilesArray[@]} == 0 )); then

     
···

       101
        
                   done

     

       102
        
               fi

     

       103
        
           fi

     

       104
       +
       

     

       105
       +
           local -r unpacked="$pkgs/.unpacked"

     

       106
       +
           for nupkg in "$pkgs"/*.nupkg; do

     

       107
       +
               rm -rf "$unpacked"

     

       108
       +
               unzip -qd "$unpacked" "$nupkg"

     

       109
       +
               chmod -R +rw "$unpacked"

     

       110
       +
               echo {} > "$unpacked"/.nupkg.metadata

     

       111
       +
               local id version

     

       112
       +
               id=$(xq -r '.package.metadata.id|ascii_downcase' "$unpacked"/*.nuspec)

     

       113
       +
               version=$(xq -r '.package.metadata.version|ascii_downcase' "$unpacked"/*.nuspec)

     

       114
       +
               mkdir -p "$out/share/nuget/packages/$id"

     

       115
       +
               mv "$unpacked" "$out/share/nuget/packages/$id/$version"

     

       116
       +
               # TODO: should we fix executable flags here?

     

       117
       +
           done

     

       118
        
       

     

       119
        
           runHook postInstall

     

       120

+71 -35

pkgs/build-support/dotnet/make-nuget-deps/default.nix

···

       1
       -
       { linkFarmFromDrvs, fetchurl, runCommand, zip }:

     

       2
       -
       { name, nugetDeps ? import sourceFile, sourceFile ? null }:

     

       3
       -
       linkFarmFromDrvs "${name}-nuget-deps" (nugetDeps {

     

       4
       -
         fetchNuGet = { pname, version, sha256 ? "", hash ? ""

     

       5
       -
           , url ? "https://www.nuget.org/api/v2/package/${pname}/${version}" }:

     

       6
       -
           let

     

       7
       -
             src = fetchurl {

     

       8
       -
               name = "${pname}.${version}.nupkg";

     

       9
       -
               # There is no need to verify whether both sha256 and hash are

     

       10
       -
               # valid here, because nuget-to-nix does not generate a deps.nix

     

       11
       -
               # containing both.

     

       12
       -
               inherit url sha256 hash;

     

       13
       -
             };

     

       14
       -
           in

     

       15
       -
           # NuGet.org edits packages by signing them during upload, which makes

     

       16
       -
           # those packages nondeterministic depending on which source you

     

       17
       -
           # get them from. We fix this by stripping out the signature file.

     

       18
       -
           # Signing logic is https://github.com/NuGet/NuGet.Client/blob/128a5066b1438627ac69a2ffe9de564b2c09ee4d/src/NuGet.Core/NuGet.Packaging/Signing/Archive/SignedPackageArchiveIOUtility.cs#L518

     

       19
       -
           # Non-NuGet.org sources might not have a signature file; in that case, zip

     

       20
       -
           # exits with code 12 ("zip has nothing to do", per `man zip`).

     

       21
       -
           runCommand src.name

     

       22
       -
             {

     

       23
       -
               inherit src;

     

       24
       -
               nativeBuildInputs = [ zip ];

     

       25
       -
             }

     

       26
       -
             ''

     

       27
       -
               zip "$src" --temp-path "$TMPDIR" --output-file "$out" --delete .signature.p7s || {

     

       28
       -
                 (( $? == 12 ))

     

       29
       -
                 install -Dm644 "$src" "$out"

     

       30
       -
               }

     

       31
       -
             '';

     

       32
       -
       })

     

       33
       -
       // {

     

       34
       -
         inherit sourceFile;

     

       35
       -
       }

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0

···

       1
       +
       { symlinkJoin

     

       2
       +
       , fetchurl

     

       3
       +
       , stdenvNoCC

     

       4
       +
       , lib

     

       5
       +
       , unzip

     

       6
       +
       , patchNupkgs

     

       7
       +
       , nugetPackageHook

     

       8
       +
       }:

     

       9
       +
       lib.makeOverridable(

     

       10
       +
         { name

     

       11
       +
         , nugetDeps ? import sourceFile

     

       12
       +
         , sourceFile ? null

     

       13
       +
         , installable ? false

     

       14
       +
         }:

     

       15
       +
         (symlinkJoin {

     

       16
       +
           name = "${name}-nuget-deps";

     

       17
       +
           paths = nugetDeps {

     

       18
       +
             fetchNuGet =

     

       19
       +
               { pname

     

       20
       +
               , version

     

       21
       +
               , sha256 ? ""

     

       22
       +
               , hash ? ""

     

       23
       +
               , url ? "https://www.nuget.org/api/v2/package/${pname}/${version}" }:

     

       24
       +
               stdenvNoCC.mkDerivation rec {

     

       25
       +
                 inherit pname version;

     

       26
       +
       

     

       27
       +
                 src = fetchurl {

     

       28
       +
                   name = "${pname}.${version}.nupkg";

     

       29
       +
                   # There is no need to verify whether both sha256 and hash are

     

       30
       +
                   # valid here, because nuget-to-nix does not generate a deps.nix

     

       31
       +
                   # containing both.

     

       32
       +
                   inherit url sha256 hash version;

     

       33
       +
                 };

     

       34
       +
       

     

       35
       +
                 nativeBuildInputs = [

     

       36
       +
                   unzip

     

       37
       +
                   patchNupkgs

     

       38
       +
                   nugetPackageHook

     

       39
       +
                 ];

     

       40
       +
       

     

       41
       +
                 unpackPhase = ''

     

       42
       +
                   unzip -nq $src

     

       43
       +
                   chmod -R +rw .

     

       44
       +
                 '';

     

       45
       +
       

     

       46
       +
                 prePatch = ''

     

       47
       +
                   shopt -s nullglob

     

       48
       +
                   local dir

     

       49
       +
                   for dir in tools runtimes/*/native; do

     

       50
       +
                     [[ ! -d "$dir" ]] || chmod -R +x "$dir"

     

       51
       +
                   done

     

       52
       +
                   rm -rf .signature.p7s

     

       53
       +
                 '';

     

       54
       +
       

     

       55
       +
                 installPhase = ''

     

       56
       +
                   dir=$out/share/nuget/packages/${lib.toLower pname}/${lib.toLower version}

     

       57
       +
                   mkdir -p $dir

     

       58
       +
                   cp -r . $dir

     

       59
       +
                   echo {} > "$dir"/.nupkg.metadata

     

       60
       +
                 '';

     

       61
       +
       

     

       62
       +
                 preFixup = ''

     

       63
       +
                   patch-nupkgs $out/share/nuget/packages

     

       64
       +
                 '';

     

       65
       +
       

     

       66
       +
                 createInstallableNugetSource = installable;

     

       67
       +
               };

     

       68
       +
           };

     

       69
       +
         }) // {

     

       70
       +
           inherit sourceFile;

     

       71
       +
         })

+4 -3

pkgs/build-support/dotnet/nuget-to-nix/nuget-to-nix.sh

···

       56
        
             continue

     

       57
        
           fi

     

       58
        
       

     

       59
       -
           used_source="$(jq -r '.source' "$version"/.nupkg.metadata)"

     

       0
        
       
     

       60
        
           found=false

     

       61
        
       

     

       62
       -
           if [[ -d "$used_source" ]]; then

     

       63
       -
               continue

     

       64
        
           fi

     

       65
        
       

     

       66
        
           for source in "${remote_sources[@]}"; do

···

       56
        
             continue

     

       57
        
           fi

     

       58
        
       

     

       59
       +
           # packages in the nix store should have an empty metadata file

     

       60
       +
           used_source="$(jq -r 'if has("source") then .source else "" end' "$version"/.nupkg.metadata)"

     

       61
        
           found=false

     

       62
        
       

     

       63
       +
           if [[ -z "$used_source" || -d "$used_source" ]]; then

     

       64
       +
             continue

     

       65
        
           fi

     

       66
        
       

     

       67
        
           for source in "${remote_sources[@]}"; do

-2

pkgs/by-name/to/torrentstream/package.nix

···

       33
        
           ./0001-display-the-message-of-caught-exceptions.patch

     

       34
        
         ];

     

       35
        
       

     

       36
       -
         postInstall = "rm $out/lib/torrentstream/NuGet.config"; # reduce closure size

     

       37
       -
       

     

       38
        
         meta = {

     

       39
        
           homepage = "https://github.com/trueromanus/TorrentStream";

     

       40
        
           description = "Simple web server for streaming torrent files in video players";

···

       33
        
           ./0001-display-the-message-of-caught-exceptions.patch

     

       34
        
         ];

     

       35
        
       

     

       0
        
       
     

       0
        
       
     

       36
        
         meta = {

     

       37
        
           homepage = "https://github.com/trueromanus/TorrentStream";

     

       38
        
           description = "Simple web server for streaming torrent files in video players";

+5 -2

pkgs/development/compilers/dotnet/combine-packages.nix

···

       1
        
       dotnetPackages:

     

       2
       -
       { buildEnv, makeWrapper, lib }:

     

       3
        
       # TODO: Rethink how we determine and/or get the CLI.

     

       4
        
       #       Possible options raised in #187118:

     

       5
        
       #         1. A separate argument for the CLI (as suggested by IvarWithoutBones

     
···

       27
        
             inherit (cli) icu;

     

       28
        
       

     

       29
        
             versions = lib.catAttrs "version" dotnetPackages;

     

       30
       -
             packages = lib.remove null (lib.catAttrs "packages" dotnetPackages);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       31
        
           };

     

       32
        
       

     

       33
        
           inherit (cli) meta;

···

       1
        
       dotnetPackages:

     

       2
       +
       { buildEnv, makeWrapper, lib, symlinkJoin }:

     

       3
        
       # TODO: Rethink how we determine and/or get the CLI.

     

       4
        
       #       Possible options raised in #187118:

     

       5
        
       #         1. A separate argument for the CLI (as suggested by IvarWithoutBones

     
···

       27
        
             inherit (cli) icu;

     

       28
        
       

     

       29
        
             versions = lib.catAttrs "version" dotnetPackages;

     

       30
       +
             packages = symlinkJoin {

     

       31
       +
               name = "combined-packages";

     

       32
       +
               paths = lib.remove null (lib.catAttrs "packages" dotnetPackages);

     

       33
       +
             };

     

       34
        
           };

     

       35
        
       

     

       36
        
           inherit (cli) meta;

+29 -32

pkgs/development/compilers/dotnet/common.nix

···

       14
        
       , swiftPackages

     

       15
        
       , darwin

     

       16
        
       , icu

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       17
        
       }: type: args: stdenv.mkDerivation (finalAttrs: args // {

     

       18
        
         doInstallCheck = true;

     

       19
        
       

     
···

       23
        
           $out/bin/dotnet --info

     

       24
        
         '';

     

       25
        
       

     

       26
       -
         # TODO: move this to sdk section?

     

       27
       -
         setupHook = writeText "dotnet-setup-hook" (''

     

       28
       -
           if [ ! -w "$HOME" ]; then

     

       29
       -
             export HOME=$(mktemp -d) # Dotnet expects a writable home directory for its configuration files

     

       30
       -
           fi

     

       0
        
       
     

       31
        
       

     

       32
       -
           export DOTNET_SKIP_FIRST_TIME_EXPERIENCE=1 # Dont try to expand NuGetFallbackFolder to disk

     

       33
       -
           export DOTNET_NOLOGO=1 # Disables the welcome message

     

       34
       -
           export DOTNET_CLI_TELEMETRY_OPTOUT=1

     

       35
       -
           export DOTNET_SKIP_WORKLOAD_INTEGRITY_CHECK=1 # Skip integrity check on first run, which fails due to read-only directory

     

       36
       -
         '' + args.setupHook or "");

     

       37
        
       

     

       38
        
         nativeBuildInputs = (args.nativeBuildInputs or []) ++ [ installShellFiles ];

     

       39
        
       

     
···

       63
        
               }:

     

       64
        
               let

     

       65
        
                 sdk = finalAttrs.finalPackage;

     

       66
       -
                 built = runCommandWith  {

     

       67
        
                   name = "dotnet-test-${name}";

     

       68
       -
                   inherit stdenv;

     

       69
       -
                   derivationArgs = {

     

       70
       -
                     buildInputs = [ sdk ] ++ buildInputs;

     

       71
       -
                     # make sure ICU works in a sandbox

     

       72
       -
                     propagatedSandboxProfile = toString sdk.__propagatedSandboxProfile;

     

       73
       -
                   };

     

       74
       -
                 } (''

     

       75
       -
                   HOME=$PWD/.home

     

       76
       -
                   dotnet new nugetconfig

     

       77
       -
                   dotnet nuget disable source nuget

     

       78
       -
                 '' + lib.optionalString usePackageSource ''

     

       79
       -
                   dotnet nuget add source ${sdk.packages}

     

       80
       -
                 '' + ''

     

       81
       -
                   dotnet new ${template} -n test -o .

     

       82
       -
                 '' + build);

     

       83
        
               in

     

       84
        
                 if run == null

     

       85
        
                   then built

     
···

       87
        
                   runCommand "${built.name}-run" ({

     

       88
        
                     src = built;

     

       89
        
                     nativeBuildInputs = [ built ] ++ runInputs;

     

       0
        
       
     

       90
        
                   } // lib.optionalAttrs (stdenv.isDarwin && runAllowNetworking) {

     

       91
        
                     sandboxProfile = ''

     

       92
        
                       (allow network-inbound (local ip))

     
···

       105
        
               # yes, older SDKs omit the comma

     

       106
        
               [[ "$output" =~ Hello,?\ World! ]] && touch "$out"

     

       107
        
             '';

     

       108
       -
       

     

       109
       -
             patchNupkgs = callPackage ./patch-nupkgs.nix {};

     

       110
       -
       

     

       111
        
           in {

     

       112
        
             version = testers.testVersion ({

     

       113
        
               package = finalAttrs.finalPackage;

     
···

       184
        
               template = "console";

     

       185
        
               usePackageSource = true;

     

       186
        
               buildInputs =

     

       187
       -
                 [ patchNupkgs

     

       188
       -
                   zlib

     

       189
        
                 ] ++ lib.optional stdenv.isDarwin (with darwin; with apple_sdk.frameworks; [

     

       190
        
                   swiftPackages.swift

     

       191
        
                   Foundation

     
···

       195
        
                 ]);

     

       196
        
               build = ''

     

       197
        
                 dotnet restore -p:PublishAot=true

     

       198
       -
                 patch-nupkgs .home/.nuget/packages

     

       199
        
                 dotnet publish -p:PublishAot=true -o $out/bin

     

       200
        
               '';

     

       201
        
               runtime = null;

···

       14
        
       , swiftPackages

     

       15
        
       , darwin

     

       16
        
       , icu

     

       17
       +
       , lndir

     

       18
       +
       , substituteAll

     

       19
       +
       , nugetPackageHook

     

       20
        
       }: type: args: stdenv.mkDerivation (finalAttrs: args // {

     

       21
        
         doInstallCheck = true;

     

       22
        
       

     
···

       26
        
           $out/bin/dotnet --info

     

       27
        
         '';

     

       28
        
       

     

       29
       +
         setupHooks = args.setupHooks or [] ++ [

     

       30
       +
           ./dotnet-setup-hook.sh

     

       31
       +
         ] ++ lib.optional (type == "sdk") (substituteAll {

     

       32
       +
           src = ./dotnet-sdk-setup-hook.sh;

     

       33
       +
           inherit lndir;

     

       34
       +
         });

     

       35
        
       

     

       36
       +
         propagatedBuildInputs =

     

       37
       +
           (args.propagatedBuildInputs or [])

     

       38
       +
           ++ [ nugetPackageHook ];

     

       0
        
       
     

       0
        
       
     

       39
        
       

     

       40
        
         nativeBuildInputs = (args.nativeBuildInputs or []) ++ [ installShellFiles ];

     

       41
        
       

     
···

       65
        
               }:

     

       66
        
               let

     

       67
        
                 sdk = finalAttrs.finalPackage;

     

       68
       +
                 built = stdenv.mkDerivation {

     

       69
        
                   name = "dotnet-test-${name}";

     

       70
       +
                   buildInputs =

     

       71
       +
                     [ sdk ]

     

       72
       +
                     ++ buildInputs

     

       73
       +
                     ++ lib.optional (usePackageSource) sdk.packages;

     

       74
       +
                   # make sure ICU works in a sandbox

     

       75
       +
                   propagatedSandboxProfile = toString sdk.__propagatedSandboxProfile;

     

       76
       +
                   unpackPhase = ''

     

       77
       +
                     mkdir test

     

       78
       +
                     cd test

     

       79
       +
                     dotnet new ${template} -o .

     

       80
       +
                   '';

     

       81
       +
                   buildPhase = build;

     

       82
       +
                   dontPatchELF = true;

     

       83
       +
                 };

     

       0
        
       
     

       84
        
               in

     

       85
        
                 if run == null

     

       86
        
                   then built

     
···

       88
        
                   runCommand "${built.name}-run" ({

     

       89
        
                     src = built;

     

       90
        
                     nativeBuildInputs = [ built ] ++ runInputs;

     

       91
       +
                     passthru = { inherit built; };

     

       92
        
                   } // lib.optionalAttrs (stdenv.isDarwin && runAllowNetworking) {

     

       93
        
                     sandboxProfile = ''

     

       94
        
                       (allow network-inbound (local ip))

     
···

       107
        
               # yes, older SDKs omit the comma

     

       108
        
               [[ "$output" =~ Hello,?\ World! ]] && touch "$out"

     

       109
        
             '';

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       110
        
           in {

     

       111
        
             version = testers.testVersion ({

     

       112
        
               package = finalAttrs.finalPackage;

     
···

       183
        
               template = "console";

     

       184
        
               usePackageSource = true;

     

       185
        
               buildInputs =

     

       186
       +
                 [ zlib

     

       0
        
       
     

       187
        
                 ] ++ lib.optional stdenv.isDarwin (with darwin; with apple_sdk.frameworks; [

     

       188
        
                   swiftPackages.swift

     

       189
        
                   Foundation

     
···

       193
        
                 ]);

     

       194
        
               build = ''

     

       195
        
                 dotnet restore -p:PublishAot=true

     

       0
        
       
     

       196
        
                 dotnet publish -p:PublishAot=true -o $out/bin

     

       197
        
               '';

     

       198
        
               runtime = null;

+52 -37

pkgs/development/compilers/dotnet/default.nix

···

       5
        
       Hashes and urls are retrieved from:

     

       6
        
       https://dotnet.microsoft.com/download/dotnet

     

       7
        
       */

     

       8
       -
       { lib, config, callPackage, recurseIntoAttrs }:

     

       9
       -
       let

     

       10
       -
         buildDotnet = attrs: callPackage (import ./build-dotnet.nix attrs) {};

     

       11
       -
         buildAttrs = {

     

       12
       -
           buildAspNetCore = attrs: buildDotnet (attrs // { type = "aspnetcore"; });

     

       13
       -
           buildNetRuntime = attrs: buildDotnet (attrs // { type = "runtime"; });

     

       14
       -
           buildNetSdk = attrs: buildDotnet (attrs // { type = "sdk"; });

     

       15
       -
         };

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       16
        
       

     

       17
       -
         ## Files in versions/ are generated automatically by update.sh ##

     

       18
       -
         dotnet_6_0 = import ./versions/6.0.nix buildAttrs;

     

       19
       -
         dotnet_7_0 = import ./versions/7.0.nix buildAttrs;

     

       20
       -
         dotnet_8_0 = import ./versions/8.0.nix buildAttrs;

     

       21
       -
         dotnet_9_0 = import ./versions/9.0.nix buildAttrs;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       22
        
       

     

       23
       -
         runtimeIdentifierMap = {

     

       24
       -
           "x86_64-linux" = "linux-x64";

     

       25
       -
           "aarch64-linux" = "linux-arm64";

     

       26
       -
           "x86_64-darwin" = "osx-x64";

     

       27
       -
           "aarch64-darwin" = "osx-arm64";

     

       28
       -
           "x86_64-windows" = "win-x64";

     

       29
       -
           "i686-windows" = "win-x86";

     

       30
       -
         };

     

       31
        
       

     

       32
       -
         # Convert a "stdenv.hostPlatform.system" to a dotnet RID

     

       33
       -
         systemToDotnetRid = system: runtimeIdentifierMap.${system} or (throw "unsupported platform ${system}");

     

       34
       -
       in

     

       35
       -
       {

     

       36
       -
         inherit systemToDotnetRid;

     

       37
        
       

     

       38
       -
         combinePackages = attrs: callPackage (import ./combine-packages.nix attrs) {};

     

       0
        
       
     

       39
        
       

     

       40
       -
         dotnet_8 = recurseIntoAttrs (callPackage ./8 { bootstrapSdk = dotnet_8_0.sdk_8_0_1xx; });

     

       41
       -
         dotnet_9 = recurseIntoAttrs (callPackage ./9 {});

     

       42
       -
       } // lib.optionalAttrs config.allowAliases {

     

       43
       -
         # EOL

     

       44
       -
         sdk_2_1 = throw "Dotnet SDK 2.1 is EOL, please use 6.0 (LTS) or 7.0 (Current)";

     

       45
       -
         sdk_2_2 = throw "Dotnet SDK 2.2 is EOL, please use 6.0 (LTS) or 7.0 (Current)";

     

       46
       -
         sdk_3_0 = throw "Dotnet SDK 3.0 is EOL, please use 6.0 (LTS) or 7.0 (Current)";

     

       47
       -
         sdk_3_1 = throw "Dotnet SDK 3.1 is EOL, please use 6.0 (LTS) or 7.0 (Current)";

     

       48
       -
         sdk_5_0 = throw "Dotnet SDK 5.0 is EOL, please use 6.0 (LTS) or 7.0 (Current)";

     

       49
       -
       } // dotnet_6_0 // dotnet_7_0 // dotnet_8_0 // dotnet_9_0

     

       0

···

       5
        
       Hashes and urls are retrieved from:

     

       6
        
       https://dotnet.microsoft.com/download/dotnet

     

       7
        
       */

     

       8
       +
       { lib

     

       9
       +
       , config

     

       10
       +
       , recurseIntoAttrs

     

       11
       +
       , generateSplicesForMkScope

     

       12
       +
       , makeScopeWithSplicing'

     

       13
       +
       }:

     

       14
       +
       

     

       15
       +
       makeScopeWithSplicing' {

     

       16
       +
         otherSplices = generateSplicesForMkScope "dotnetCorePackages";

     

       17
       +
         f = (self:

     

       18
       +
           let

     

       19
       +
             callPackage = self.callPackage;

     

       20
       +
       

     

       21
       +
             buildDotnet = attrs: callPackage (import ./build-dotnet.nix attrs) {};

     

       22
       +
             buildAttrs = {

     

       23
       +
               buildAspNetCore = attrs: buildDotnet (attrs // { type = "aspnetcore"; });

     

       24
       +
               buildNetRuntime = attrs: buildDotnet (attrs // { type = "runtime"; });

     

       25
       +
               buildNetSdk = attrs: buildDotnet (attrs // { type = "sdk"; });

     

       26
       +
             };

     

       27
       +
       

     

       28
       +
             ## Files in versions/ are generated automatically by update.sh ##

     

       29
       +
             dotnet_6_0 = import ./versions/6.0.nix buildAttrs;

     

       30
       +
             dotnet_7_0 = import ./versions/7.0.nix buildAttrs;

     

       31
       +
             dotnet_8_0 = import ./versions/8.0.nix buildAttrs;

     

       32
       +
             dotnet_9_0 = import ./versions/9.0.nix buildAttrs;

     

       33
        
       

     

       34
       +
             runtimeIdentifierMap = {

     

       35
       +
               "x86_64-linux" = "linux-x64";

     

       36
       +
               "aarch64-linux" = "linux-arm64";

     

       37
       +
               "x86_64-darwin" = "osx-x64";

     

       38
       +
               "aarch64-darwin" = "osx-arm64";

     

       39
       +
               "x86_64-windows" = "win-x64";

     

       40
       +
               "i686-windows" = "win-x86";

     

       41
       +
             };

     

       42
       +
       

     

       43
       +
           in {

     

       44
       +
             inherit callPackage;

     

       45
        
       

     

       46
       +
             # Convert a "stdenv.hostPlatform.system" to a dotnet RID

     

       47
       +
             systemToDotnetRid = system: runtimeIdentifierMap.${system} or (throw "unsupported platform ${system}");

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       48
        
       

     

       49
       +
             combinePackages = attrs: callPackage (import ./combine-packages.nix attrs) {};

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       50
        
       

     

       51
       +
             patchNupkgs = callPackage ./patch-nupkgs.nix {};

     

       52
       +
             nugetPackageHook = callPackage ./nuget-package-hook.nix {};

     

       53
        
       

     

       54
       +
             dotnet_8 = recurseIntoAttrs (callPackage ./8 { bootstrapSdk = dotnet_8_0.sdk_8_0_1xx; });

     

       55
       +
             dotnet_9 = recurseIntoAttrs (callPackage ./9 {});

     

       56
       +
           } // lib.optionalAttrs config.allowAliases {

     

       57
       +
             # EOL

     

       58
       +
             sdk_2_1 = throw "Dotnet SDK 2.1 is EOL, please use 6.0 (LTS) or 7.0 (Current)";

     

       59
       +
             sdk_2_2 = throw "Dotnet SDK 2.2 is EOL, please use 6.0 (LTS) or 7.0 (Current)";

     

       60
       +
             sdk_3_0 = throw "Dotnet SDK 3.0 is EOL, please use 6.0 (LTS) or 7.0 (Current)";

     

       61
       +
             sdk_3_1 = throw "Dotnet SDK 3.1 is EOL, please use 6.0 (LTS) or 7.0 (Current)";

     

       62
       +
             sdk_5_0 = throw "Dotnet SDK 5.0 is EOL, please use 6.0 (LTS) or 7.0 (Current)";

     

       63
       +
           } // dotnet_6_0 // dotnet_7_0 // dotnet_8_0 // dotnet_9_0);

     

       64
       +
       }

+77

pkgs/development/compilers/dotnet/dotnet-sdk-setup-hook.sh

···

       1
       +
       # shellcheck shell=bash disable=SC2154

     

       2
       +
       export MSBUILDALWAYSOVERWRITEREADONLYFILES=1

     

       3
       +
       

     

       4
       +
       declare -Ag _nugetInputs

     

       5
       +
       

     

       6
       +
       addNugetInputs() {

     

       7
       +
           if [[ -d "$1/share/nuget" ]]; then

     

       8
       +
               _nugetInputs[$1]=1

     

       9
       +
           fi

     

       10
       +
       }

     

       11
       +
       

     

       12
       +
       addEnvHooks "$targetOffset" addNugetInputs

     

       13
       +
       

     

       14
       +
       _linkPackages() {

     

       15
       +
           local -r src="$1"

     

       16
       +
           local -r dest="$2"

     

       17
       +
           local dir

     

       18
       +
       

     

       19
       +
           for x in "$src"/*/*; do

     

       20
       +
               dir=$dest/$(basename "$(dirname "$x")")

     

       21
       +
               mkdir -p "$dir"

     

       22
       +
               ln -s "$x" "$dir"/

     

       23
       +
           done

     

       24
       +
       }

     

       25
       +
       

     

       26
       +
       createNugetDirs() {

     

       27
       +
           nugetTemp=$PWD/.nuget-temp

     

       28
       +
           export NUGET_PACKAGES=$nugetTemp/packages

     

       29
       +
           nugetSource=$nugetTemp/source

     

       30
       +
           mkdir -p "$NUGET_PACKAGES" "$nugetSource"

     

       31
       +
       

     

       32
       +
           dotnet new nugetconfig

     

       33
       +
           if [[ -z ${keepNugetConfig-} ]]; then

     

       34
       +
               dotnet nuget disable source nuget

     

       35
       +
           fi

     

       36
       +
       

     

       37
       +
           dotnet nuget add source "$nugetSource" -n _nix

     

       38
       +
       }

     

       39
       +
       

     

       40
       +
       configureNuget() {

     

       41
       +
           for x in "${!_nugetInputs[@]}"; do

     

       42
       +
               if [[ -d $x/share/nuget/packages ]]; then

     

       43
       +
                   addToSearchPathWithCustomDelimiter ";" NUGET_FALLBACK_PACKAGES "$x/share/nuget/packages"

     

       44
       +
               fi

     

       45
       +
       

     

       46
       +
               if [[ -d $x/share/nuget/source ]]; then

     

       47
       +
                   _linkPackages "$x/share/nuget/source" "$nugetSource"

     

       48
       +
               fi

     

       49
       +
           done

     

       50
       +
       

     

       51
       +
           if [[ -n "${linkNugetPackages-}"

     

       52
       +
               || -f .config/dotnet-tools.json

     

       53
       +
               || -f dotnet-tools.json

     

       54
       +
               || -f paket.dependencies ]]; then

     

       55
       +
               for x in "${!_nugetInputs[@]}"; do

     

       56
       +
                   if [[ -d $x/share/nuget/packages ]]; then

     

       57
       +
                       @lndir@/bin/lndir -silent "$x/share/nuget/packages" "$NUGET_PACKAGES"

     

       58
       +
                   fi

     

       59
       +
               done

     

       60
       +
           fi

     

       61
       +
       

     

       62
       +
           if [[ -f paket.dependencies ]]; then

     

       63
       +
              sed -i "s:source .*:source $nugetSource:" paket.dependencies

     

       64
       +
              sed -i "s:remote\:.*:remote\: $nugetSource:" paket.lock

     

       65
       +
       

     

       66
       +
              for x in "${!_nugetInputs[@]}"; do

     

       67
       +
                  if [[ -d $x/share/nuget/source ]]; then

     

       68
       +
                      @lndir@/bin/lndir -silent "$x/share/nuget/source" "$NUGET_PACKAGES"

     

       69
       +
                  fi

     

       70
       +
              done

     

       71
       +
           fi

     

       72
       +
       }

     

       73
       +
       

     

       74
       +
       if [[ -z ${dontConfigureNuget-} ]]; then

     

       75
       +
           prePhases+=(createNugetDirs)

     

       76
       +
           preConfigurePhases+=(configureNuget)

     

       77
       +
       fi

pkgs/development/compilers/dotnet/dotnet-setup-hook.sh

···

       1
       +
       if [ ! -w "$HOME" ]; then

     

       2
       +
           export HOME=$(mktemp -d) # Dotnet expects a writable home directory for its configuration files

     

       3
       +
       fi

     

       4
       +
       

     

       5
       +
       export DOTNET_SKIP_FIRST_TIME_EXPERIENCE=1 # Dont try to expand NuGetFallbackFolder to disk

     

       6
       +
       export DOTNET_NOLOGO=1 # Disables the welcome message

     

       7
       +
       export DOTNET_CLI_TELEMETRY_OPTOUT=1

     

       8
       +
       export DOTNET_SKIP_WORKLOAD_INTEGRITY_CHECK=1 # Skip integrity check on first run, which fails due to read-only directory

-1

pkgs/development/compilers/dotnet/dotnet.nix

···

       32
        
                   installPhase = ''

     

       33
        
                     mkdir -p $out

     

       34
        
                     cp -r * $out/

     

       35
       -
                     ln -fs ${old.passthru.packages}/* $out/

     

       36
        
                   '';

     

       37
        
                 };

     

       38
        
               };

···

       32
        
                   installPhase = ''

     

       33
        
                     mkdir -p $out

     

       34
        
                     cp -r * $out/

     

       0
        
       
     

       35
        
                   '';

     

       36
        
                 };

     

       37
        
               };

+12

pkgs/development/compilers/dotnet/nuget-package-hook.nix

···

       1
       +
       {

     

       2
       +
         makeSetupHook,

     

       3
       +
         zip,

     

       4
       +
         strip-nondeterminism,

     

       5
       +
       }:

     

       6
       +
       makeSetupHook {

     

       7
       +
         name = "nuget-package-hook";

     

       8
       +
         substitutions = {

     

       9
       +
           inherit zip;

     

       10
       +
           stripNondeterminism = strip-nondeterminism;

     

       11
       +
         };

     

       12
       +
       } ./nuget-package-hook.sh

+38

pkgs/development/compilers/dotnet/nuget-package-hook.sh

···

       1
       +
       # shellcheck shell=bash disable=SC2154

     

       2
       +
       

     

       3
       +
       _createNugetSourceInOutput() {

     

       4
       +
           local package version id dir nupkg content

     

       5
       +
           local -a nuspec

     

       6
       +
           shopt -s nullglob

     

       7
       +
       

     

       8
       +
           for package in "$prefix"/share/nuget/packages/*/*; do

     

       9
       +
               version=$(basename "$package")

     

       10
       +
               id=$(basename "$(dirname "$package")")

     

       11
       +
               dir="$prefix/share/nuget/source/$id/$version"

     

       12
       +
               nupkg=$dir/$id.$version.nupkg

     

       13
       +
               nuspec=("$package"/*.nuspec)

     

       14
       +
       

     

       15
       +
               if [[ -n ${createInstallableNugetSource-} ]]; then

     

       16
       +
                   content=.

     

       17
       +
               else

     

       18
       +
                   content=$(basename "${nuspec[0]}")

     

       19
       +
               fi

     

       20
       +
       

     

       21
       +
               mkdir -p "$dir"

     

       22
       +
               cp "${nuspec[0]}" "$dir/$id.nuspec"

     

       23
       +
               (cd "$package" && @zip@/bin/zip -rq0 "$nupkg" "$content")

     

       24
       +
               @stripNondeterminism@/bin/strip-nondeterminism --type zip "$nupkg"

     

       25
       +
               touch "$nupkg".sha512

     

       26
       +
           done

     

       27
       +
       }

     

       28
       +
       

     

       29
       +
       createNugetSource() {

     

       30
       +
           local output

     

       31
       +
           for output in $(getAllOutputNames); do

     

       32
       +
               prefix="${!output}" _createNugetSourceInOutput

     

       33
       +
           done

     

       34
       +
       }

     

       35
       +
       

     

       36
       +
       if [[ -z ${dontCreateNugetSource-} ]]; then

     

       37
       +
           postFixupHooks+=(createNugetSource)

     

       38
       +
       fi

+49 -4

pkgs/development/compilers/dotnet/packages.nix

···

       1
        
       { stdenv

     

       2
        
       , callPackage

     

       3
        
       , vmr

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       4
        
       }:

     

       5
        
       

     

       6
        
       let

     
···

       16
        
           src = vmr;

     

       17
        
           dontUnpack = true;

     

       18
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       19
        
           outputs = [ "out" "packages" "artifacts" ];

     

       20
        
       

     

       21
        
           installPhase = ''

     
···

       26
        
             mkdir "$out"/bin

     

       27
        
             ln -s "$out"/dotnet "$out"/bin/dotnet

     

       28
        
       

     

       29
       -
             mkdir "$packages"

     

       30
       -
             # this roughly corresponds to the {sdk,aspnetcore}_packages in ../update.sh

     

       31
       -
             cp -r "$src"/Private.SourceBuilt.Artifacts.*.${targetRid}/*Microsoft.{NET.ILLink.Tasks,NETCore,DotNet,AspNetCore}.*.nupkg "$packages"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       32
        
       

     

       33
       -
             cp -r "$src"/Private.SourceBuilt.Artifacts.*.${targetRid} "$artifacts"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       34
        
       

     

       35
        
             runHook postInstall

     

       36
        
           '';

···

       1
        
       { stdenv

     

       2
        
       , callPackage

     

       3
        
       , vmr

     

       4
       +
       , xmlstarlet

     

       5
       +
       , strip-nondeterminism

     

       6
       +
       , zip

     

       7
        
       }:

     

       8
        
       

     

       9
        
       let

     
···

       19
        
           src = vmr;

     

       20
        
           dontUnpack = true;

     

       21
        
       

     

       22
       +
           nativeBuildInputs = [

     

       23
       +
             xmlstarlet

     

       24
       +
             strip-nondeterminism

     

       25
       +
             zip

     

       26
       +
           ];

     

       27
       +
       

     

       28
        
           outputs = [ "out" "packages" "artifacts" ];

     

       29
        
       

     

       30
        
           installPhase = ''

     
···

       35
        
             mkdir "$out"/bin

     

       36
        
             ln -s "$out"/dotnet "$out"/bin/dotnet

     

       37
        
       

     

       38
       +
             mkdir -p "$packages" "$artifacts"

     

       39
       +
             cp -r "$src"/Private.SourceBuilt.Artifacts.*.${targetRid}/* "$artifacts"/

     

       40
       +
             chmod +w -R "$artifacts"

     

       41
       +
       

     

       42
       +
             local package

     

       43
       +
       

     

       44
       +
             for package in "$artifacts"/*.nupkg; do

     

       45
       +
               local copy

     

       46
       +
               case "$(basename "$package")" in

     

       47
       +
                 *Microsoft.NET.* | \

     

       48
       +
                 *Microsoft.ILLink.* | \

     

       49
       +
                 *Microsoft.Tasks.* | \

     

       50
       +
                 *Microsoft.NETCore.* | \

     

       51
       +
                 *Microsoft.DotNet.* | \

     

       52
       +
                 *Microsoft.AspNetCore.*) copy=1 ;;

     

       53
       +
                 *) copy= ;;

     

       54
       +
               esac

     

       55
       +
               if [[ -n $copy ]]; then

     

       56
       +
                 echo copying "$package" to packages

     

       57
       +
                 xmlstarlet \

     

       58
       +
                   sel -t \

     

       59
       +
                   -m /_:package/_:metadata \

     

       60
       +
                   -v _:id -nl \

     

       61
       +
                   -v _:version -nl \

     

       62
       +
                   "$package"/*.nuspec \

     

       63
       +
                   | tr A-Z a-z | (

     

       64
       +
                   read id

     

       65
       +
                   read version

     

       66
       +
                   mkdir -p "$packages"/share/nuget/packages/"$id"

     

       67
       +
                   cp -r "$package" "$packages"/share/nuget/packages/"$id"/"$version"

     

       68
       +
                 )

     

       69
       +
               fi

     

       70
       +
             done

     

       71
        
       

     

       72
       +
             for package in "$artifacts"/{,SourceBuildReferencePackages/}*.nupkg; do

     

       73
       +
               echo packing "$package" to artifacts

     

       74
       +
               (cd "$package" && zip -rq0 "$package.tmp" .)

     

       75
       +
               strip-nondeterminism --type zip "$package.tmp"

     

       76
       +
               rm -r "$package"

     

       77
       +
               mv "$package.tmp" "$package"

     

       78
       +
             done

     

       79
        
       

     

       80
        
             runHook postInstall

     

       81
        
           '';

+5 -10

pkgs/development/compilers/dotnet/patch-nupkgs.nix

···

       1
        
       { stdenv

     

       2
        
       , lib

     

       3
       -
       , dotnetCorePackages

     

       4
        
       , zlib

     

       5
        
       , curl

     

       6
        
       , icu

     
···

       12
        
       }:

     

       13
        
       

     

       14
        
       let

     

       15
       -
         buildRid = dotnetCorePackages.systemToDotnetRid stdenv.buildPlatform.system;

     

       16
       -
       

     

       17
        
         binaryRPath = lib.makeLibraryPath ([

     

       18
        
           stdenv.cc.cc

     

       19
        
           zlib

     
···

       37
        
             if [ "$magic" = $'\177ELF' ]; then return 0; else return 1; fi

     

       38
        
         }

     

       39
        
         cd "$1"

     

       40
       -
         for x in *.${buildRid}/* *.${buildRid}.*/*; do

     

       41
        
           # .nupkg.metadata is written last, so we know the packages is complete

     

       42
        
           [[ -d "$x" ]] && [[ -f "$x"/.nupkg.metadata ]] \

     

       43
        
             && [[ ! -f "$x"/.nix-patched ]] || continue

     

       44
        
           echo "Patching package $x"

     

       45
       -
           pushd "$x"

     

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

     

       47
        
             if [[ "$p" != *.nix-patched ]] \

     

       48
        
               && isELF "$p" \

     

       49
        
               && patchelf --print-interpreter "$p" &>/dev/null; then

     
···

       68
        
               mv "$tmp" "$p"

     

       69
        
             fi

     

       70
        
           done

     

       71
       -
           touch .nix-patched

     

       72
       -
           popd

     

       73
        
         done

     

       74
        
       '' + lib.optionalString stdenv.isDarwin ''

     

       75
        
         for x in microsoft.dotnet.ilcompiler/*; do

     

       76
        
           # .nupkg.metadata is written last, so we know the packages is complete

     

       77
        
           [[ -d "$x" ]] && [[ -f "$x"/.nupkg.metadata ]] \

     

       78
       -
             && [[ ! -f "$x"/.nix-patched ]] || continue

     

       79
        
           echo "Patching package $x"

     

       80
        
           pushd "$x"

     

       81
        
           sed -i 's: -no_code_signature_warning::g' build/Microsoft.NETCore.Native.targets

     

       82
        
           sed -i 's:Include="-ld_classic"::g' build/Microsoft.NETCore.Native.Unix.targets

     

       83
       -
           touch .nix-patched

     

       84
        
           popd

     

       85
        
         done

     

       86
        
       '')

···

       1
        
       { stdenv

     

       2
        
       , lib

     

       0
        
       
     

       3
        
       , zlib

     

       4
        
       , curl

     

       5
        
       , icu

     
···

       11
        
       }:

     

       12
        
       

     

       13
        
       let

     

       0
        
       
     

       0
        
       
     

       14
        
         binaryRPath = lib.makeLibraryPath ([

     

       15
        
           stdenv.cc.cc

     

       16
        
           zlib

     
···

       34
        
             if [ "$magic" = $'\177ELF' ]; then return 0; else return 1; fi

     

       35
        
         }

     

       36
        
         cd "$1"

     

       37
       +
         for x in */* */*; do

     

       38
        
           # .nupkg.metadata is written last, so we know the packages is complete

     

       39
        
           [[ -d "$x" ]] && [[ -f "$x"/.nupkg.metadata ]] \

     

       40
        
             && [[ ! -f "$x"/.nix-patched ]] || continue

     

       41
        
           echo "Patching package $x"

     

       42
       +
           find "$x" -type f -print0 | while IFS= read -rd "" p; do

     

       0
        
       
     

       43
        
             if [[ "$p" != *.nix-patched ]] \

     

       44
        
               && isELF "$p" \

     

       45
        
               && patchelf --print-interpreter "$p" &>/dev/null; then

     
···

       64
        
               mv "$tmp" "$p"

     

       65
        
             fi

     

       66
        
           done

     

       67
       +
           touch "$x"/.nix-patched

     

       0
        
       
     

       68
        
         done

     

       69
        
       '' + lib.optionalString stdenv.isDarwin ''

     

       70
        
         for x in microsoft.dotnet.ilcompiler/*; do

     

       71
        
           # .nupkg.metadata is written last, so we know the packages is complete

     

       72
        
           [[ -d "$x" ]] && [[ -f "$x"/.nupkg.metadata ]] \

     

       73
       +
             && [[ ! -f "$x"/.nix-patched-ilcompiler ]] || continue

     

       74
        
           echo "Patching package $x"

     

       75
        
           pushd "$x"

     

       76
        
           sed -i 's: -no_code_signature_warning::g' build/Microsoft.NETCore.Native.targets

     

       77
        
           sed -i 's:Include="-ld_classic"::g' build/Microsoft.NETCore.Native.Unix.targets

     

       78
       +
           touch .nix-patched-ilcompiler

     

       79
        
           popd

     

       80
        
         done

     

       81
        
       '')

+10 -5

pkgs/development/compilers/dotnet/stage0.nix

···

       3
        
       , callPackage

     

       4
        
       , lib

     

       5
        
       , writeShellScript

     

       6
       -
       , pkgsBuildHost

     

       7
        
       , mkNugetDeps

     

       8
        
       , nix

     

       9
        
       , cacert

     

       10
        
       , nuget-to-nix

     

       11
        
       , dotnetCorePackages

     

       12
        
       , xmlstarlet

     

       0
        
       
     

       13
        
       

     

       14
        
       , releaseManifestFile

     

       15
        
       , tarballHash

     
···

       21
        
         mkPackages = callPackage ./packages.nix;

     

       22
        
         mkVMR = callPackage ./vmr.nix;

     

       23
        
       

     

       24
       -
         dotnetSdk = pkgsBuildHost.callPackage bootstrapSdk {};

     

       25
       -
       

     

       26
       -
         patchNupkgs = pkgsBuildHost.callPackage ./patch-nupkgs.nix {};

     

       27
        
       

     

       28
        
         deps = mkNugetDeps {

     

       29
        
           name = "dotnet-vmr-deps";

     

       30
        
           sourceFile = depsFile;

     

       31
        
         };

     

       32
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       33
        
         vmr = (mkVMR {

     

       34
        
           inherit releaseManifestFile tarballHash dotnetSdk;

     

       35
        
         }).overrideAttrs (old: rec {

     

       36
        
           prebuiltPackages = mkNugetDeps {

     

       37
        
             name = "dotnet-vmr-deps";

     

       38
        
             sourceFile = depsFile;

     

       0
        
       
     

       39
        
           };

     

       40
        
       

     

       41
        
           nativeBuildInputs =

     
···

       52
        
           '';

     

       53
        
       

     

       54
        
           postConfigure = old.postConfigure or "" + ''

     

       55
       -
             [[ ! -v prebuiltPackages ]] || ln -sf "$prebuiltPackages"/* prereqs/packages/prebuilt/

     

       0
        
       
     

       0
        
       
     

       56
        
           '';

     

       57
        
       

     

       58
        
           buildFlags =

···

       3
        
       , callPackage

     

       4
        
       , lib

     

       5
        
       , writeShellScript

     

       0
        
       
     

       6
        
       , mkNugetDeps

     

       7
        
       , nix

     

       8
        
       , cacert

     

       9
        
       , nuget-to-nix

     

       10
        
       , dotnetCorePackages

     

       11
        
       , xmlstarlet

     

       12
       +
       , patchNupkgs

     

       13
        
       

     

       14
        
       , releaseManifestFile

     

       15
        
       , tarballHash

     
···

       21
        
         mkPackages = callPackage ./packages.nix;

     

       22
        
         mkVMR = callPackage ./vmr.nix;

     

       23
        
       

     

       24
       +
         dotnetSdk = callPackage bootstrapSdk {};

     

       0
        
       
     

       0
        
       
     

       25
        
       

     

       26
        
         deps = mkNugetDeps {

     

       27
        
           name = "dotnet-vmr-deps";

     

       28
        
           sourceFile = depsFile;

     

       29
        
         };

     

       30
        
       

     

       31
       +
         sdkPackages = dotnetSdk.packages.override {

     

       32
       +
           installable = true;

     

       33
       +
         };

     

       34
       +
       

     

       35
        
         vmr = (mkVMR {

     

       36
        
           inherit releaseManifestFile tarballHash dotnetSdk;

     

       37
        
         }).overrideAttrs (old: rec {

     

       38
        
           prebuiltPackages = mkNugetDeps {

     

       39
        
             name = "dotnet-vmr-deps";

     

       40
        
             sourceFile = depsFile;

     

       41
       +
             installable = true;

     

       42
        
           };

     

       43
        
       

     

       44
        
           nativeBuildInputs =

     
···

       55
        
           '';

     

       56
        
       

     

       57
        
           postConfigure = old.postConfigure or "" + ''

     

       58
       +
             [[ ! -v prebuiltPackages ]] || \

     

       59
       +
               ln -sf "$prebuiltPackages"/share/nuget/source/*/*/*.nupkg prereqs/packages/prebuilt/

     

       60
       +
             ln -sf "${sdkPackages}"/share/nuget/source/*/*/*.nupkg prereqs/packages/prebuilt/

     

       61
        
           '';

     

       62
        
       

     

       63
        
           buildFlags =

+1 -2

pkgs/development/compilers/dotnet/stage1.nix

···

       1
        
       { stdenv

     

       2
        
       , lib

     

       3
        
       , callPackage

     

       4
       -
       , pkgsBuildHost

     

       5
        
       

     

       6
        
       , releaseManifestFile

     

       7
        
       , tarballHash

     
···

       13
        
         mkPackages = callPackage ./packages.nix;

     

       14
        
         mkVMR = callPackage ./vmr.nix;

     

       15
        
       

     

       16
       -
         stage0 = pkgsBuildHost.callPackage ./stage0.nix args;

     

       17
        
       

     

       18
        
         vmr = (mkVMR {

     

       19
        
           inherit releaseManifestFile tarballHash;

···

       1
        
       { stdenv

     

       2
        
       , lib

     

       3
        
       , callPackage

     

       0
        
       
     

       4
        
       

     

       5
        
       , releaseManifestFile

     

       6
        
       , tarballHash

     
···

       12
        
         mkPackages = callPackage ./packages.nix;

     

       13
        
         mkVMR = callPackage ./vmr.nix;

     

       14
        
       

     

       15
       +
         stage0 = callPackage ./stage0.nix args;

     

       16
        
       

     

       17
        
         vmr = (mkVMR {

     

       18
        
           inherit releaseManifestFile tarballHash;

+21 -1

pkgs/development/compilers/dotnet/vmr.nix

···

       25
        
       , xmlstarlet

     

       26
        
       , nodejs

     

       27
        
       , callPackage

     

       0
        
       
     

       0
        
       
     

       28
        
       

     

       29
        
       , dotnetSdk

     

       30
        
       , releaseManifestFile

     
···

       78
        
           pkg-config

     

       79
        
           python3

     

       80
        
           xmlstarlet

     

       0
        
       
     

       0
        
       
     

       81
        
         ]

     

       82
        
         ++ lib.optionals (lib.versionAtLeast version "9") [

     

       83
        
           nodejs

     
···

       353
        
           typeset -f isScript patchShebangs > src/aspnetcore/patch-shebangs.sh

     

       354
        
         '';

     

       355
        
       

     

       0
        
       
     

       356
        
         dontUseCmakeConfigure = true;

     

       357
        
       

     

       358
        
         # https://github.com/NixOS/nixpkgs/issues/38991

     
···

       410
        
           done

     

       411
        
           popd

     

       412
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       413
        
           runHook postInstall

     

       414
        
         '';

     

       415
        
       

     
···

       418
        
         stripDebugList = [ "." ];

     

       419
        
         # stripping dlls results in:

     

       420
        
         # Failed to load System.Private.CoreLib.dll (error code 0x8007000B)

     

       421
       -
         stripExclude = [ "*.dll" ];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       422
        
       

     

       423
        
         passthru = {

     

       424
        
           inherit releaseManifest buildRid targetRid;

···

       25
        
       , xmlstarlet

     

       26
        
       , nodejs

     

       27
        
       , callPackage

     

       28
       +
       , unzip

     

       29
       +
       , yq

     

       30
        
       

     

       31
        
       , dotnetSdk

     

       32
        
       , releaseManifestFile

     
···

       80
        
           pkg-config

     

       81
        
           python3

     

       82
        
           xmlstarlet

     

       83
       +
           unzip

     

       84
       +
           yq

     

       85
        
         ]

     

       86
        
         ++ lib.optionals (lib.versionAtLeast version "9") [

     

       87
        
           nodejs

     
···

       357
        
           typeset -f isScript patchShebangs > src/aspnetcore/patch-shebangs.sh

     

       358
        
         '';

     

       359
        
       

     

       360
       +
         dontConfigureNuget = true; # NUGET_PACKAGES breaks the build

     

       361
        
         dontUseCmakeConfigure = true;

     

       362
        
       

     

       363
        
         # https://github.com/NixOS/nixpkgs/issues/38991

     
···

       415
        
           done

     

       416
        
           popd

     

       417
        
       

     

       418
       +
           local -r unpacked="$PWD/.unpacked"

     

       419
       +
           for nupkg in $out/Private.SourceBuilt.Artifacts.*.${targetRid}/{,SourceBuildReferencePackages/}*.nupkg; do

     

       420
       +
               rm -rf "$unpacked"

     

       421
       +
               unzip -qd "$unpacked" "$nupkg"

     

       422
       +
               chmod -R +rw "$unpacked"

     

       423
       +
               rm "$nupkg"

     

       424
       +
               mv "$unpacked" "$nupkg"

     

       425
       +
               # TODO: should we fix executable flags here? see dotnetInstallHook

     

       426
       +
           done

     

       427
       +
       

     

       428
        
           runHook postInstall

     

       429
        
         '';

     

       430
        
       

     
···

       433
        
         stripDebugList = [ "." ];

     

       434
        
         # stripping dlls results in:

     

       435
        
         # Failed to load System.Private.CoreLib.dll (error code 0x8007000B)

     

       436
       +
         # stripped crossgen2 results in:

     

       437
       +
         # Failure processing application bundle; possible file corruption.

     

       438
       +
         # this needs to be a bash array

     

       439
       +
         preFixup = ''

     

       440
       +
           stripExclude=(\*.dll crossgen2)

     

       441
       +
         '';

     

       442
        
       

     

       443
        
         passthru = {

     

       444
        
           inherit releaseManifest buildRid targetRid;

+7 -4

pkgs/development/python-modules/clr-loader/default.nix

···

       36
        
       

     

       37
        
         format = "pyproject";

     

       38
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       39
        
         nativeBuildInputs = [

     

       40
        
           setuptools

     

       41
        
           setuptools-scm

     
···

       59
        
         preConfigure = ''

     

       60
        
           dotnet restore "netfx_loader/ClrLoader.csproj" \

     

       61
        
             -p:ContinuousIntegrationBuild=true \

     

       62
       -
             -p:Deterministic=true \

     

       63
       -
             --source "${dotnet-build.nuget-source}"

     

       64
        
       

     

       65
        
           dotnet restore "example/example.csproj" \

     

       66
        
             -p:ContinuousIntegrationBuild=true \

     

       67
       -
             -p:Deterministic=true \

     

       68
       -
             --source "${dotnet-build.nuget-source}"

     

       69
        
         '';

     

       70
        
       

     

       71
        
         passthru.fetch-deps = dotnet-build.fetch-deps;

···

       36
        
       

     

       37
        
         format = "pyproject";

     

       38
        
       

     

       39
       +
         buildInputs = [

     

       40
       +
           dotnetCorePackages.sdk_6_0.packages

     

       41
       +
           dotnet-build.nugetDeps

     

       42
       +
         ];

     

       43
       +
       

     

       44
        
         nativeBuildInputs = [

     

       45
        
           setuptools

     

       46
        
           setuptools-scm

     
···

       64
        
         preConfigure = ''

     

       65
        
           dotnet restore "netfx_loader/ClrLoader.csproj" \

     

       66
        
             -p:ContinuousIntegrationBuild=true \

     

       67
       +
             -p:Deterministic=true

     

       0
        
       
     

       68
        
       

     

       69
        
           dotnet restore "example/example.csproj" \

     

       70
        
             -p:ContinuousIntegrationBuild=true \

     

       71
       +
             -p:Deterministic=true

     

       0
        
       
     

       72
        
         '';

     

       73
        
       

     

       74
        
         passthru.fetch-deps = dotnet-build.fetch-deps;

+3 -1

pkgs/development/python-modules/pythonnet/default.nix

···

       37
        
             --replace 'dynamic = ["version"]' 'version = "${version}"'

     

       38
        
         '';

     

       39
        
       

     

       0
        
       
     

       0
        
       
     

       40
        
         nativeBuildInputs = [

     

       41
        
           setuptools

     

       42
        
           dotnet-sdk

     
···

       62
        
           dotnet restore \

     

       63
        
             -p:ContinuousIntegrationBuild=true \

     

       64
        
             -p:Deterministic=true \

     

       65
       -
             --source ${dotnet-build.nuget-source}

     

       66
        
         '';

     

       67
        
       

     

       68
        
         # Rerun this when updating to refresh Nuget dependencies

···

       37
        
             --replace 'dynamic = ["version"]' 'version = "${version}"'

     

       38
        
         '';

     

       39
        
       

     

       40
       +
         buildInputs = [ dotnet-build.nugetDeps ];

     

       41
       +
       

     

       42
        
         nativeBuildInputs = [

     

       43
        
           setuptools

     

       44
        
           dotnet-sdk

     
···

       64
        
           dotnet restore \

     

       65
        
             -p:ContinuousIntegrationBuild=true \

     

       66
        
             -p:Deterministic=true \

     

       67
       +
             --source "$nugetSource"

     

       68
        
         '';

     

       69
        
       

     

       70
        
         # Rerun this when updating to refresh Nuget dependencies

pkgs/development/tools/build-managers/msbuild/default.nix

···

       65
        
         '';

     

       66
        
       

     

       67
        
         buildPhase = ''

     

       0
        
       
     

       68
        
           # nuget would otherwise try to base itself in /homeless-shelter

     

       69
        
           export HOME=$(pwd)/fake-home

     

       70

···

       65
        
         '';

     

       66
        
       

     

       67
        
         buildPhase = ''

     

       68
       +
           unset NUGET_PACKAGES

     

       69
        
           # nuget would otherwise try to base itself in /homeless-shelter

     

       70
        
           export HOME=$(pwd)/fake-home

     

       71

-14

pkgs/development/tools/fsautocomplete/deps.nix

···

       54
        
         (fetchNuGet { pname = "McMaster.NETCore.Plugins"; version = "1.4.0"; hash = "sha256-PtpD8S74UXyoA80YRDlrp8qR/I7Ws7+4m2EJZzH4WMw="; })

     

       55
        
         (fetchNuGet { pname = "MessagePack"; version = "2.5.108"; hash = "sha256-+vMXyEbfutY5WOFuFnNF24uLcKJTTdntVrVlSJH4yjI="; })

     

       56
        
         (fetchNuGet { pname = "MessagePack.Annotations"; version = "2.5.108"; hash = "sha256-u3Qu8UftNIz3oIzQUMa7Z0G6VzmDLcAnAeNQ3lB3YVk="; })

     

       57
       -
         (fetchNuGet { pname = "Microsoft.AspNetCore.App.Ref"; version = "6.0.32"; hash = "sha256-1mQTxwruzhm20YdlZefrYuy7xrBs17pH4Vo0K3Tl7Fc="; })

     

       58
       -
         (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.linux-arm64"; version = "6.0.32"; hash = "sha256-cIe0F+7rgwYSmh0VuFuQsUI9iEW5hn2KCD2H8Cs/k2g="; })

     

       59
       -
         (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.linux-x64"; version = "6.0.32"; hash = "sha256-TkYv7h9NBr3I+FIaXeLU4MawJtgT2RWhs35ewGRDKx8="; })

     

       60
       -
         (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.osx-arm64"; version = "6.0.32"; hash = "sha256-RaC37ZQcJn7ykXJrtV7ibxh0GcalRyPKncxlqOLou+I="; })

     

       61
       -
         (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.osx-x64"; version = "6.0.32"; hash = "sha256-vh/e46xM/HbhbBvL5eP5/DCHwCP2Bg7WoMS28nBXWV0="; })

     

       62
        
         (fetchNuGet { pname = "Microsoft.Bcl.AsyncInterfaces"; version = "7.0.0"; hash = "sha256-1e031E26iraIqun84ad0fCIR4MJZ1hcQo4yFN+B7UfE="; })

     

       63
        
         (fetchNuGet { pname = "Microsoft.Bcl.HashCode"; version = "1.1.0"; hash = "sha256-IFvXCMV2joahytylQ2BGSpZd2tdX0Rss++ZcClVT+r0="; })

     

       64
        
         (fetchNuGet { pname = "Microsoft.Build"; version = "17.2.0"; hash = "sha256-JzPqbxFyotNhSr5tokVevdqB9+nJKx4YH2hPkC05GiY="; })

     
···

       96
        
         (fetchNuGet { pname = "Microsoft.Extensions.Primitives"; version = "6.0.0"; hash = "sha256-AgvysszpQ11AiTBJFkvSy8JnwIWTj15Pfek7T7ThUc4="; })

     

       97
        
         (fetchNuGet { pname = "Microsoft.NET.StringTools"; version = "17.4.0"; hash = "sha256-+9uBaUDZ3roUJwyYJUL30Mz+3C6LE16FzfQKgS0Yveo="; })

     

       98
        
         (fetchNuGet { pname = "Microsoft.NET.Test.Sdk"; version = "17.4.1"; hash = "sha256-Kl8ZAWCMFZcYEfPDr/YG4zfQEuEzlOuhWI40Zl2S4Qo="; })

     

       99
       -
         (fetchNuGet { pname = "Microsoft.NETCore.App.Host.linux-arm64"; version = "6.0.32"; hash = "sha256-yDOkSHEGuGG6u+rB5u+IC3rc2tQwvbjdqmgHcl7Gkn4="; })

     

       100
       -
         (fetchNuGet { pname = "Microsoft.NETCore.App.Host.linux-x64"; version = "6.0.32"; hash = "sha256-2aDGkn0QqXXHUUSAwtQQbjKl5I6S0fcQWPciqPnOiM4="; })

     

       101
       -
         (fetchNuGet { pname = "Microsoft.NETCore.App.Host.osx-arm64"; version = "6.0.32"; hash = "sha256-n6hks4j88TRelq1O6SCeUH5GmxoSm5BWXGwnpnYJibI="; })

     

       102
       -
         (fetchNuGet { pname = "Microsoft.NETCore.App.Host.osx-x64"; version = "6.0.32"; hash = "sha256-nBBq4RYAgimBYOn/bN6JTFvJFYaqYXMHae2pmCzRaS8="; })

     

       103
       -
         (fetchNuGet { pname = "Microsoft.NETCore.App.Ref"; version = "6.0.32"; hash = "sha256-Fm3RUZNcro434rIu3c7unGviGeGBjXj2dGnr2mmrM2g="; })

     

       104
       -
         (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.linux-arm64"; version = "6.0.32"; hash = "sha256-kdj8ia/2du2oKGg4MJdO2XytpT3gQ9UOiHVCyfiX2V8="; })

     

       105
       -
         (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.linux-x64"; version = "6.0.32"; hash = "sha256-/Hti30Ba12NDJQcG8pFTg6REVUDIrxZ/hRtEZNDlgxE="; })

     

       106
       -
         (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.osx-arm64"; version = "6.0.32"; hash = "sha256-A8MFGOMXFROH1QGUE7xzq5b5EskDyIQCQt7SLfGdSbU="; })

     

       107
       -
         (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.osx-x64"; version = "6.0.32"; hash = "sha256-y5YB62WlMrK10bR/+nNpI8luVRlD9W9ZG3GsX7AXzUM="; })

     

       108
        
         (fetchNuGet { pname = "Microsoft.NETCore.Platforms"; version = "1.1.1"; hash = "sha256-8hLiUKvy/YirCWlFwzdejD2Db3DaXhHxT7GSZx/znJg="; })

     

       109
        
         (fetchNuGet { pname = "Microsoft.NETCore.Targets"; version = "1.1.3"; hash = "sha256-WLsf1NuUfRWyr7C7Rl9jiua9jximnVvzy6nk2D2bVRc="; })

     

       110
        
         (fetchNuGet { pname = "Microsoft.NETFramework.ReferenceAssemblies"; version = "1.0.3"; hash = "sha256-FBoJP5DHZF0QHM0xLm9yd4HJZVQOuSpSKA+VQRpphEE="; })

···

       54
        
         (fetchNuGet { pname = "McMaster.NETCore.Plugins"; version = "1.4.0"; hash = "sha256-PtpD8S74UXyoA80YRDlrp8qR/I7Ws7+4m2EJZzH4WMw="; })

     

       55
        
         (fetchNuGet { pname = "MessagePack"; version = "2.5.108"; hash = "sha256-+vMXyEbfutY5WOFuFnNF24uLcKJTTdntVrVlSJH4yjI="; })

     

       56
        
         (fetchNuGet { pname = "MessagePack.Annotations"; version = "2.5.108"; hash = "sha256-u3Qu8UftNIz3oIzQUMa7Z0G6VzmDLcAnAeNQ3lB3YVk="; })

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       57
        
         (fetchNuGet { pname = "Microsoft.Bcl.AsyncInterfaces"; version = "7.0.0"; hash = "sha256-1e031E26iraIqun84ad0fCIR4MJZ1hcQo4yFN+B7UfE="; })

     

       58
        
         (fetchNuGet { pname = "Microsoft.Bcl.HashCode"; version = "1.1.0"; hash = "sha256-IFvXCMV2joahytylQ2BGSpZd2tdX0Rss++ZcClVT+r0="; })

     

       59
        
         (fetchNuGet { pname = "Microsoft.Build"; version = "17.2.0"; hash = "sha256-JzPqbxFyotNhSr5tokVevdqB9+nJKx4YH2hPkC05GiY="; })

     
···

       91
        
         (fetchNuGet { pname = "Microsoft.Extensions.Primitives"; version = "6.0.0"; hash = "sha256-AgvysszpQ11AiTBJFkvSy8JnwIWTj15Pfek7T7ThUc4="; })

     

       92
        
         (fetchNuGet { pname = "Microsoft.NET.StringTools"; version = "17.4.0"; hash = "sha256-+9uBaUDZ3roUJwyYJUL30Mz+3C6LE16FzfQKgS0Yveo="; })

     

       93
        
         (fetchNuGet { pname = "Microsoft.NET.Test.Sdk"; version = "17.4.1"; hash = "sha256-Kl8ZAWCMFZcYEfPDr/YG4zfQEuEzlOuhWI40Zl2S4Qo="; })

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       94
        
         (fetchNuGet { pname = "Microsoft.NETCore.Platforms"; version = "1.1.1"; hash = "sha256-8hLiUKvy/YirCWlFwzdejD2Db3DaXhHxT7GSZx/znJg="; })

     

       95
        
         (fetchNuGet { pname = "Microsoft.NETCore.Targets"; version = "1.1.3"; hash = "sha256-WLsf1NuUfRWyr7C7Rl9jiua9jximnVvzy6nk2D2bVRc="; })

     

       96
        
         (fetchNuGet { pname = "Microsoft.NETFramework.ReferenceAssemblies"; version = "1.0.3"; hash = "sha256-FBoJP5DHZF0QHM0xLm9yd4HJZVQOuSpSKA+VQRpphEE="; })

+3 -27

pkgs/development/tools/godot/3/mono/default.nix

···

       1
        
       { godot3

     

       2
        
       , callPackage

     

       3
        
       , mkNugetDeps

     

       4
       -
       , mkNugetSource

     

       5
        
       , mono

     

       6
        
       , dotnet-sdk

     

       7
       -
       , writeText

     

       8
        
       , scons

     

       9
        
       , python311Packages

     

       10
        
       }:

     
···

       22
        
       

     

       23
        
         glue = callPackage ./glue.nix {};

     

       24
        
       

     

       25
       -
         nugetDeps = mkNugetDeps { name = "deps"; nugetDeps = import ./deps.nix; };

     

       26
       -
       

     

       27
       -
         nugetSource =

     

       28
       -
           mkNugetSource {

     

       29
       -
             name = "${self.pname}-nuget-source";

     

       30
       -
             description = "Nuget source with dependencies for ${self.pname}";

     

       31
       -
             deps = [ self.nugetDeps ];

     

       32
       -
           };

     

       33
       -
       

     

       34
       -
         nugetConfig = writeText "NuGet.Config" ''

     

       35
       -
           <?xml version="1.0" encoding="utf-8"?>

     

       36
       -
           <configuration>

     

       37
       -
             <packageSources>

     

       38
       -
               <add key="${self.pname}-deps" value="${self.nugetSource}/lib" />

     

       39
       -
             </packageSources>

     

       40
       -
           </configuration>

     

       41
       -
         '';

     

       42
        
       

     

       43
        
         sconsFlags = base.sconsFlags ++ [

     

       44
        
           "module_mono_enabled=true"

     

       45
        
           "mono_prefix=${mono}"

     

       46
        
         ];

     

       47
        
       

     

       48
       -
         shouldConfigureNuget = true;

     

       49
       -
       

     

       50
        
         postConfigure = ''

     

       51
        
           echo "Setting up buildhome."

     

       52
        
           mkdir buildhome

     
···

       54
        
       

     

       55
        
           echo "Overlaying godot glue."

     

       56
        
           cp -R --no-preserve=mode "$glue"/. .

     

       57
       -
       

     

       58
       -
           if [ -n "$shouldConfigureNuget" ]; then

     

       59
       -
             echo "Configuring NuGet."

     

       60
       -
             mkdir -p ~/.nuget/NuGet

     

       61
       -
             ln -s "$nugetConfig" ~/.nuget/NuGet/NuGet.Config

     

       62
       -
           fi

     

       63
        
         '';

     

       64
        
       

     

       65
        
         installedGodotShortcutFileName = "org.godotengine.GodotMono3.desktop";

···

       1
        
       { godot3

     

       2
        
       , callPackage

     

       3
        
       , mkNugetDeps

     

       0
        
       
     

       4
        
       , mono

     

       5
        
       , dotnet-sdk

     

       0
        
       
     

       6
        
       , scons

     

       7
        
       , python311Packages

     

       8
        
       }:

     
···

       20
        
       

     

       21
        
         glue = callPackage ./glue.nix {};

     

       22
        
       

     

       23
       +
         buildInputs = base.buildInputs ++ [

     

       24
       +
           (mkNugetDeps { name = "deps"; nugetDeps = import ./deps.nix; })

     

       25
       +
         ];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       26
        
       

     

       27
        
         sconsFlags = base.sconsFlags ++ [

     

       28
        
           "module_mono_enabled=true"

     

       29
        
           "mono_prefix=${mono}"

     

       30
        
         ];

     

       31
        
       

     

       0
        
       
     

       0
        
       
     

       32
        
         postConfigure = ''

     

       33
        
           echo "Setting up buildhome."

     

       34
        
           mkdir buildhome

     
···

       36
        
       

     

       37
        
           echo "Overlaying godot glue."

     

       38
        
           cp -R --no-preserve=mode "$glue"/. .

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       39
        
         '';

     

       40
        
       

     

       41
        
         installedGodotShortcutFileName = "org.godotengine.GodotMono3.desktop";

+1 -1

pkgs/development/tools/godot/3/mono/make-deps.nix

···

       9
        
         nugetSource = null;

     

       10
        
         nugetConfig = null;

     

       11
        
       

     

       12
       -
         shouldConfigureNuget = false;

     

       13
        
       

     

       14
        
         outputs = [ "out" ];

     

       15
        
         buildPhase = " ";

···

       9
        
         nugetSource = null;

     

       10
        
         nugetConfig = null;

     

       11
        
       

     

       12
       +
         keepNugetConfig = true;

     

       13
        
       

     

       14
        
         outputs = [ "out" ];

     

       15
        
         buildPhase = " ";

pkgs/development/tools/ilspycmd/default.nix

···

       32
        
         projectFile = "ICSharpCode.ILSpyCmd/ICSharpCode.ILSpyCmd.csproj";

     

       33
        
         nugetDeps = ./deps.nix;

     

       34
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       35
        
         meta = with lib; {

     

       36
        
           description = "Tool for decompiling .NET assemblies and generating portable PDBs";

     

       37
        
           mainProgram = "ilspycmd";

···

       32
        
         projectFile = "ICSharpCode.ILSpyCmd/ICSharpCode.ILSpyCmd.csproj";

     

       33
        
         nugetDeps = ./deps.nix;

     

       34
        
       

     

       35
       +
         # see: https://github.com/tunnelvisionlabs/ReferenceAssemblyAnnotator/issues/94

     

       36
       +
         linkNugetPackages = true;

     

       37
       +
       

     

       38
        
         meta = with lib; {

     

       39
        
           description = "Tool for decompiling .NET assemblies and generating portable PDBs";

     

       40
        
           mainProgram = "ilspycmd";

-7

pkgs/servers/nosql/eventstore/default.nix

···

       42
        
           "EventStore.Projections.Core.Tests.Services.grpc_service.ServerFeaturesTests<LogFormat+V3,UInt32>.should_receive_expected_endpoints"

     

       43
        
         ];

     

       44
        
       

     

       45
       -
         postConfigure = ''

     

       46
       -
           # Fixes git execution by GitInfo on mac os

     

       47
       -
           substituteInPlace "$HOME/.nuget/packages/gitinfo/2.0.26/build/GitInfo.targets" \

     

       48
       -
             --replace "<GitExe Condition=\"Exists('/usr/bin/git')\">/usr/bin/git</GitExe>" " " \

     

       49
       -
             --replace "<GitExe Condition=\"Exists('/usr/local/bin/git')\">/usr/local/bin/git</GitExe>" ""

     

       50
       -
         '';

     

       51
       -
       

     

       52
        
         nugetDeps = ./deps.nix;

     

       53
        
       

     

       54
        
         projectFile = "src/EventStore.ClusterNode/EventStore.ClusterNode.csproj";

···

       42
        
           "EventStore.Projections.Core.Tests.Services.grpc_service.ServerFeaturesTests<LogFormat+V3,UInt32>.should_receive_expected_endpoints"

     

       43
        
         ];

     

       44
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       45
        
         nugetDeps = ./deps.nix;

     

       46
        
       

     

       47
        
         projectFile = "src/EventStore.ClusterNode/EventStore.ClusterNode.csproj";

+1 -1

pkgs/top-level/all-packages.nix

···

       891
        
         buildDotnetModule = callPackage ../build-support/dotnet/build-dotnet-module { };

     

       892
        
         nuget-to-nix = callPackage ../build-support/dotnet/nuget-to-nix { };

     

       893
        
         mkNugetSource = callPackage ../build-support/dotnet/make-nuget-source { };

     

       894
       -
         mkNugetDeps = callPackage ../build-support/dotnet/make-nuget-deps { };

     

       895
        
       

     

       896
        
         buildDotnetGlobalTool = callPackage ../build-support/dotnet/build-dotnet-global-tool { };

     

       897

···

       891
        
         buildDotnetModule = callPackage ../build-support/dotnet/build-dotnet-module { };

     

       892
        
         nuget-to-nix = callPackage ../build-support/dotnet/nuget-to-nix { };

     

       893
        
         mkNugetSource = callPackage ../build-support/dotnet/make-nuget-source { };

     

       894
       +
         mkNugetDeps = (newScope dotnetCorePackages) ../build-support/dotnet/make-nuget-deps { };

     

       895
        
       

     

       896
        
         buildDotnetGlobalTool = callPackage ../build-support/dotnet/build-dotnet-global-tool { };

     

       897