commit 043eab9a5ac2ac3bdabd541fb3180e80c47c2b2c · pyrox.dev/nixpkgs

pkgs/development/compilers/dotnet/8/default.nix

···

       1
       1
       +
       { callPackage

     

       2
       2
       +
       , dotnetCorePackages

     

       3
       3
       +
       , bootstrapSdk

     

       4
       4
       +
       }: callPackage ../dotnet.nix {

     

       5
       5
       +
         releaseManifestFile = ./release.json;

     

       6
       6
       +
         releaseInfoFile = ./release-info.json;

     

       7
       7
       +
         depsFile = ./deps.nix;

     

       8
       8
       +
         inherit bootstrapSdk;

     

       9
       9
       +
       }

+10

pkgs/development/compilers/dotnet/8/deps.nix

···

       1
       1
       +
       { fetchNuGet }: [

     

       2
       2
       +
         (fetchNuGet { pname = "runtime.linux-arm64.Microsoft.NETCore.ILAsm"; sha256 = "8985f0b9855daaf8b4a38f32a91902bdbb99a2f1801a98c68a5013d94842524e"; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/a65e5cb4-26c0-410f-9457-06db3c5254be/nuget/v3/flat2/runtime.linux-arm64.microsoft.netcore.ilasm/8.0.1-servicing.23580.1/runtime.linux-arm64.microsoft.netcore.ilasm.8.0.1-servicing.23580.1.nupkg"; version = "8.0.1-servicing.23580.1"; })

     

       3
       3
       +
         (fetchNuGet { pname = "runtime.linux-arm64.Microsoft.NETCore.ILDAsm"; sha256 = "0496a403691e50662c5aef598248d8cd92ad1da1e93a859aedee5bb91bb9c821"; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/a65e5cb4-26c0-410f-9457-06db3c5254be/nuget/v3/flat2/runtime.linux-arm64.microsoft.netcore.ildasm/8.0.1-servicing.23580.1/runtime.linux-arm64.microsoft.netcore.ildasm.8.0.1-servicing.23580.1.nupkg"; version = "8.0.1-servicing.23580.1"; })

     

       4
       4
       +
         (fetchNuGet { pname = "runtime.linux-x64.Microsoft.NETCore.ILAsm"; sha256 = "0c5k9ckp7zjspyqqzz817jr8pglnn7wxhmv2hfk700swb96qhg0w"; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/a65e5cb4-26c0-410f-9457-06db3c5254be/nuget/v3/flat2/runtime.linux-x64.microsoft.netcore.ilasm/8.0.1-servicing.23580.1/runtime.linux-x64.microsoft.netcore.ilasm.8.0.1-servicing.23580.1.nupkg"; version = "8.0.1-servicing.23580.1"; })

     

       5
       5
       +
         (fetchNuGet { pname = "runtime.linux-x64.Microsoft.NETCore.ILDAsm"; sha256 = "1pyydnypv9x25p7y35j85f8pxnyxq3w2vc8i84klq90kzgzig5a8"; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/a65e5cb4-26c0-410f-9457-06db3c5254be/nuget/v3/flat2/runtime.linux-x64.microsoft.netcore.ildasm/8.0.1-servicing.23580.1/runtime.linux-x64.microsoft.netcore.ildasm.8.0.1-servicing.23580.1.nupkg"; version = "8.0.1-servicing.23580.1"; })

     

       6
       6
       +
         (fetchNuGet { pname = "runtime.osx-arm64.Microsoft.NETCore.ILAsm"; sha256 = "7609cfc7fd617a580caba18d458ed644ab799346139b3ead9df9502abe8d0541"; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/a65e5cb4-26c0-410f-9457-06db3c5254be/nuget/v3/flat2/runtime.osx-arm64.microsoft.netcore.ilasm/8.0.1-servicing.23580.1/runtime.osx-arm64.microsoft.netcore.ilasm.8.0.1-servicing.23580.1.nupkg"; version = "8.0.1-servicing.23580.1"; })

     

       7
       7
       +
         (fetchNuGet { pname = "runtime.osx-arm64.Microsoft.NETCore.ILDAsm"; sha256 = "6a969c2f6261834ab8ec9829cffed5a1a1f35667bf382b7c902d1b26db192e27"; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/a65e5cb4-26c0-410f-9457-06db3c5254be/nuget/v3/flat2/runtime.osx-arm64.microsoft.netcore.ildasm/8.0.1-servicing.23580.1/runtime.osx-arm64.microsoft.netcore.ildasm.8.0.1-servicing.23580.1.nupkg"; version = "8.0.1-servicing.23580.1"; })

     

       8
       8
       +
         (fetchNuGet { pname = "runtime.osx-x64.Microsoft.NETCore.ILAsm"; sha256 = "a8b90caa9ead7defdf8b9570dcb3e0cec146dff892a88fb825fedb7ee0fe620f"; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/a65e5cb4-26c0-410f-9457-06db3c5254be/nuget/v3/flat2/runtime.osx-x64.microsoft.netcore.ilasm/8.0.1-servicing.23580.1/runtime.osx-x64.microsoft.netcore.ilasm.8.0.1-servicing.23580.1.nupkg"; version = "8.0.1-servicing.23580.1"; })

     

       9
       9
       +
         (fetchNuGet { pname = "runtime.osx-x64.Microsoft.NETCore.ILDAsm"; sha256 = "eade428d642bdbb2271610c5d781a61ab367dbd3e776477a7b5948bda62252b5"; url = "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/a65e5cb4-26c0-410f-9457-06db3c5254be/nuget/v3/flat2/runtime.osx-x64.microsoft.netcore.ildasm/8.0.1-servicing.23580.1/runtime.osx-x64.microsoft.netcore.ildasm.8.0.1-servicing.23580.1.nupkg"; version = "8.0.1-servicing.23580.1"; })

     

       10
       10
       +
       ]

pkgs/development/compilers/dotnet/8/release-info.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "tarballHash": "sha256-OTCFPhQ9PHnQ0f7UzgHryEsBIaKCOm/L6pkURw/RY2s=",

     

       3
       3
       +
         "artifactsUrl": "https://dotnetcli.azureedge.net/source-built-artifacts/assets/Private.SourceBuilt.Artifacts.8.0.101-servicing.23601.1.centos.8-x64.tar.gz",

     

       4
       4
       +
         "artifactsHash": "sha256-RLrEPFkB9NvnzJFJ0zSFbGNpMKR4EsyBu3T/JwAxgzc="

     

       5
       5
       +
       }

pkgs/development/compilers/dotnet/8/release.json

···

       1
       1
       +
       {

     

       2
       2
       +
         "release": "8.0.2",

     

       3
       3
       +
         "channel": "8.0",

     

       4
       4
       +
         "tag": "v8.0.2",

     

       5
       5
       +
         "sdkVersion": "8.0.102",

     

       6
       6
       +
         "runtimeVersion": "8.0.2",

     

       7
       7
       +
         "sourceRepository": "https://github.com/dotnet/dotnet",

     

       8
       8
       +
         "sourceVersion": "d396b0c4d3e51c2d8d679b2f7233912bc5bfc2fa"

     

       9
       9
       +
       }

+9 -57

pkgs/development/compilers/dotnet/build-dotnet.nix

···

       24
       24
        
       , runCommand

     

       25
       25
        
       , writeShellScript

     

       26
       26
        
       , mkNugetDeps

     

       27
       27
       +
       , callPackage

     

       27
       28
        
       }:

     

       28
       29
        
       

     

       29
       30
        
       let

     
···

       41
       42
        
           sdk = ".NET SDK ${version}";

     

       42
       43
        
         };

     

       43
       44
        
       

     

       44
       44
       -
         packageDeps = if type == "sdk" then mkNugetDeps {

     

       45
       45
       -
           name = "${pname}-${version}-deps";

     

       46
       46
       -
           nugetDeps = packages;

     

       47
       47
       -
         } else null;

     

       45
       45
       +
         mkCommon = callPackage ./common.nix {};

     

       48
       46
        
       

     

       49
       47
        
       in

     

       50
       50
       -
       stdenv.mkDerivation (finalAttrs: rec {

     

       48
       48
       +
       mkCommon type rec {

     

       51
       49
        
         inherit pname version;

     

       52
       50
        
       

     

       53
       51
        
         # Some of these dependencies are `dlopen()`ed.

     
···

       88
       86
        
           runHook postInstall

     

       89
       87
        
         '';

     

       90
       88
        
       

     

       91
       91
       -
         doInstallCheck = true;

     

       92
       92
       -
         installCheckPhase = ''

     

       93
       93
       -
           $out/bin/dotnet --info

     

       94
       94
       -
         '';

     

       95
       95
       -
       

     

       96
       89
        
         # Tell autoPatchelf about runtime dependencies.

     

       97
       90
        
         # (postFixup phase is run before autoPatchelfHook.)

     

       98
       91
        
         postFixup = lib.optionalString stdenv.isLinux ''

     
···

       112
       105
        
             $out/packs/Microsoft.NETCore.App.Host.linux-x64/*/runtimes/linux-x64/native/singlefilehost

     

       113
       106
        
         '';

     

       114
       107
        
       

     

       115
       115
       -
         setupHook = writeText "dotnet-setup-hook" ''

     

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

     

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

     

       118
       118
       -
           fi

     

       119
       119
       -
       

     

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

     

       121
       121
       -
           export DOTNET_NOLOGO=1 # Disables the welcome message

     

       122
       122
       -
           export DOTNET_CLI_TELEMETRY_OPTOUT=1

     

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

     

       124
       124
       -
         '';

     

       125
       125
       -
       

     

       126
       108
        
         passthru = {

     

       127
       109
        
           inherit icu;

     

       128
       128
       -
           packages = packageDeps;

     

       110
       110
       +
         } // lib.optionalAttrs (type == "sdk") {

     

       111
       111
       +
           packages = mkNugetDeps {

     

       112
       112
       +
             name = "${pname}-${version}-deps";

     

       113
       113
       +
             nugetDeps = packages;

     

       114
       114
       +
           };

     

       129
       115
        
       

     

       130
       116
        
           updateScript =

     

       131
       131
       -
             if type == "sdk" then

     

       132
       117
        
             let

     

       133
       118
        
               majorVersion =

     

       134
       119
        
                 with lib;

     
···

       137
       122
        
             writeShellScript "update-dotnet-${majorVersion}" ''

     

       138
       123
        
               pushd pkgs/development/compilers/dotnet

     

       139
       124
        
               exec ${./update.sh} "${majorVersion}"

     

       140
       140
       -
             '' else null;

     

       141
       141
       -
       

     

       142
       142
       -
           tests = {

     

       143
       143
       -
             version = testers.testVersion {

     

       144
       144
       -
               package = finalAttrs.finalPackage;

     

       145
       145
       -
             };

     

       146
       146
       -
       

     

       147
       147
       -
             console = runCommand "dotnet-test-console" {

     

       148
       148
       -
               nativeBuildInputs = [ finalAttrs.finalPackage ];

     

       149
       149
       -
             } ''

     

       150
       150
       -
               HOME=$(pwd)/fake-home

     

       151
       151
       -
               dotnet new nugetconfig

     

       152
       152
       -
               dotnet nuget disable source nuget

     

       153
       153
       -
               dotnet new console -n test -o .

     

       154
       154
       -
               output="$(dotnet run)"

     

       155
       155
       -
               # yes, older SDKs omit the comma

     

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

     

       157
       125
        
             '';

     

       158
       158
       -
       

     

       159
       159
       -
             single-file = let build = runCommand "dotnet-test-build-single-file" {

     

       160
       160
       -
               nativeBuildInputs = [ finalAttrs.finalPackage ];

     

       161
       161
       -
             } ''

     

       162
       162
       -
               HOME=$(pwd)/fake-home

     

       163
       163
       -
               dotnet new nugetconfig

     

       164
       164
       -
               dotnet nuget disable source nuget

     

       165
       165
       -
               dotnet nuget add source ${finalAttrs.finalPackage.packages}

     

       166
       166
       -
               dotnet new console -n test -o .

     

       167
       167
       -
               dotnet publish --use-current-runtime -p:PublishSingleFile=true -o $out

     

       168
       168
       -
             ''; in runCommand "dotnet-test-run-single-file" {} ''

     

       169
       169
       -
               output="$(${build}/test)"

     

       170
       170
       -
               # yes, older SDKs omit the comma

     

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

     

       172
       172
       -
             '';

     

       173
       173
       -
           };

     

       174
       126
        
         };

     

       175
       127
        
       

     

       176
       128
        
         meta = with lib; {

     
···

       181
       133
        
           mainProgram = "dotnet";

     

       182
       134
        
           platforms = attrNames srcs;

     

       183
       135
        
         };

     

       184
       184
       -
       })

     

       136
       136
       +
       }

+40

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

···

       1
       1
       +
       {

     

       2
       2
       +
         list,

     

       3
       3
       +
         baseRid,

     

       4
       4
       +
         otherRids,

     

       5
       5
       +
         pkgs ? import ../../../.. {}

     

       6
       6
       +
       }:

     

       7
       7
       +
       with pkgs.lib;

     

       8
       8
       +
       let

     

       9
       9
       +
         inherit (pkgs) writeText;

     

       10
       10
       +
       

     

       11
       11
       +
         fns = map (file: import file) list;

     

       12
       12
       +
         packages = unique

     

       13
       13
       +
           (concatMap (fn: fn { fetchNuGet = package: package; }) fns);

     

       14
       14
       +
       

     

       15
       15
       +
         changePackageRid = package: rid:

     

       16
       16
       +
           let replace = replaceStrings [".${baseRid}"] [".${rid}"];

     

       17
       17
       +
           in rec {

     

       18
       18
       +
             pname = replace package.pname;

     

       19
       19
       +
             inherit (package) version;

     

       20
       20
       +
             url = replace package.url;

     

       21
       21
       +
             sha256 = builtins.hashFile "sha256" (builtins.fetchurl url);

     

       22
       22
       +
           };

     

       23
       23
       +
       

     

       24
       24
       +
         expandPackage = package:

     

       25
       25
       +
           [ package ] ++

     

       26
       26
       +
           optionals (strings.match ".*\\.${baseRid}(\\..*|$)" package.pname != null)

     

       27
       27
       +
           (map (changePackageRid package) otherRids);

     

       28
       28
       +
       

     

       29
       29
       +
         allPackages =

     

       30
       30
       +
           sortOn (package: [ package.pname package.version package ])

     

       31
       31
       +
           (concatMap expandPackage packages);

     

       32
       32
       +
       

     

       33
       33
       +
         fetchExpr = package:

     

       34
       34
       +
           "  (fetchNuGet ${generators.toPretty { multiline = false; } package})";

     

       35
       35
       +
       

     

       36
       36
       +
       in writeText "deps.nix" ''

     

       37
       37
       +
         { fetchNuGet }: [

     

       38
       38
       +
         ${concatMapStringsSep "\n" fetchExpr allPackages}

     

       39
       39
       +
         ]

     

       40
       40
       +
       ''

+63

pkgs/development/compilers/dotnet/common.nix

···

       1
       1
       +
       # TODO: switch to stdenvNoCC

     

       2
       2
       +
       { stdenv

     

       3
       3
       +
       , lib

     

       4
       4
       +
       , writeText

     

       5
       5
       +
       , testers

     

       6
       6
       +
       , runCommand

     

       7
       7
       +
       }: type: args: stdenv.mkDerivation (finalAttrs: args // {

     

       8
       8
       +
         doInstallCheck = true;

     

       9
       9
       +
       

     

       10
       10
       +
         # TODO: this should probably be postInstallCheck

     

       11
       11
       +
         # TODO: send output to /dev/null

     

       12
       12
       +
         installCheckPhase = args.installCheckPhase or "" + ''

     

       13
       13
       +
           $out/bin/dotnet --info

     

       14
       14
       +
         '';

     

       15
       15
       +
       

     

       16
       16
       +
         # TODO: move this to sdk section?

     

       17
       17
       +
         setupHook = writeText "dotnet-setup-hook" (''

     

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

     

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

     

       20
       20
       +
           fi

     

       21
       21
       +
       

     

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

     

       23
       23
       +
           export DOTNET_NOLOGO=1 # Disables the welcome message

     

       24
       24
       +
           export DOTNET_CLI_TELEMETRY_OPTOUT=1

     

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

     

       26
       26
       +
         '' + args.setupHook or "");

     

       27
       27
       +
       

     

       28
       28
       +
       } // lib.optionalAttrs (type == "sdk") {

     

       29
       29
       +
         passthru = {

     

       30
       30
       +
           tests = {

     

       31
       31
       +
             version = testers.testVersion {

     

       32
       32
       +
               package = finalAttrs.finalPackage;

     

       33
       33
       +
             };

     

       34
       34
       +
       

     

       35
       35
       +
             console = runCommand "dotnet-test-console" {

     

       36
       36
       +
               nativeBuildInputs = [ finalAttrs.finalPackage ];

     

       37
       37
       +
             } ''

     

       38
       38
       +
               HOME=$(pwd)/fake-home

     

       39
       39
       +
               dotnet new nugetconfig

     

       40
       40
       +
               dotnet nuget disable source nuget

     

       41
       41
       +
               dotnet new console -n test -o .

     

       42
       42
       +
               output="$(dotnet run)"

     

       43
       43
       +
               # yes, older SDKs omit the comma

     

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

     

       45
       45
       +
             '';

     

       46
       46
       +
       

     

       47
       47
       +
             single-file = let build = runCommand "dotnet-test-build-single-file" {

     

       48
       48
       +
               nativeBuildInputs = [ finalAttrs.finalPackage ];

     

       49
       49
       +
             } ''

     

       50
       50
       +
               HOME=$(pwd)/fake-home

     

       51
       51
       +
               dotnet new nugetconfig

     

       52
       52
       +
               dotnet nuget disable source nuget

     

       53
       53
       +
               dotnet nuget add source ${finalAttrs.finalPackage.packages}

     

       54
       54
       +
               dotnet new console -n test -o .

     

       55
       55
       +
               dotnet publish --use-current-runtime -p:PublishSingleFile=true -o $out

     

       56
       56
       +
             ''; in runCommand "dotnet-test-run-single-file" {} ''

     

       57
       57
       +
               output="$(${build}/test)"

     

       58
       58
       +
               # yes, older SDKs omit the comma

     

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

     

       60
       60
       +
             '';

     

       61
       61
       +
           } // args.passthru.tests or {};

     

       62
       62
       +
         } // args.passthru or {};

     

       63
       63
       +
       })

+4 -1

pkgs/development/compilers/dotnet/default.nix

···

       5
       5
        
       Hashes and urls are retrieved from:

     

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

     

       7
       7
        
       */

     

       8
       8
       -
       { lib, config, callPackage }:

     

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

     

       9
       9
        
       let

     

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

     

       11
       11
        
         buildAttrs = {

     
···

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

     

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

     

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

     

       21
       21
       +
         dotnet_8_0_102 = import ./versions/8.0.102.nix buildAttrs;

     

       21
       22
        
       

     

       22
       23
        
         runtimeIdentifierMap = {

     

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

     
···

       35
       36
        
         inherit systemToDotnetRid;

     

       36
       37
        
       

     

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

     

       39
       39
       +
       

     

       40
       40
       +
         dotnet_8 = recurseIntoAttrs (callPackage ./8 { bootstrapSdk = dotnet_8_0_102.sdk_8_0; });

     

       38
       41
        
       } // lib.optionalAttrs config.allowAliases {

     

       39
       42
        
         # EOL

     

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

+50

pkgs/development/compilers/dotnet/dotnet.nix

···

       1
       1
       +
       { callPackage

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , releaseManifestFile

     

       4
       4
       +
       , releaseInfoFile

     

       5
       5
       +
       , allowPrerelease ? false

     

       6
       6
       +
       , depsFile

     

       7
       7
       +
       , bootstrapSdk

     

       8
       8
       +
       , pkgsBuildHost

     

       9
       9
       +
       }:

     

       10
       10
       +
       

     

       11
       11
       +
       let

     

       12
       12
       +
         inherit (lib.importJSON releaseInfoFile) tarballHash artifactsUrl artifactsHash;

     

       13
       13
       +
       

     

       14
       14
       +
         pkgs = callPackage ./stage1.nix {

     

       15
       15
       +
           inherit releaseManifestFile tarballHash depsFile;

     

       16
       16
       +
           bootstrapSdk =

     

       17
       17
       +
             { stdenvNoCC

     

       18
       18
       +
             , dotnetCorePackages

     

       19
       19
       +
             , fetchurl

     

       20
       20
       +
             }: bootstrapSdk.overrideAttrs (old: {

     

       21
       21
       +
               passthru = old.passthru or {} // {

     

       22
       22
       +
                 artifacts = stdenvNoCC.mkDerivation rec {

     

       23
       23
       +
                   name = lib.nameFromURL artifactsUrl ".tar.gz";

     

       24
       24
       +
       

     

       25
       25
       +
                   src = fetchurl {

     

       26
       26
       +
                     url = artifactsUrl;

     

       27
       27
       +
                     hash = artifactsHash;

     

       28
       28
       +
                   };

     

       29
       29
       +
       

     

       30
       30
       +
                   sourceRoot = ".";

     

       31
       31
       +
       

     

       32
       32
       +
                   installPhase = ''

     

       33
       33
       +
                     mkdir -p $out

     

       34
       34
       +
                     cp -r * $out/

     

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

     

       36
       36
       +
                   '';

     

       37
       37
       +
                 };

     

       38
       38
       +
               };

     

       39
       39
       +
             });

     

       40
       40
       +
         };

     

       41
       41
       +
       

     

       42
       42
       +
       in pkgs // {

     

       43
       43
       +
         vmr = pkgs.vmr.overrideAttrs(old: {

     

       44
       44
       +
           passthru = old.passthru // {

     

       45
       45
       +
             updateScript = pkgsBuildHost.callPackage ./update.nix {

     

       46
       46
       +
               inherit releaseManifestFile releaseInfoFile allowPrerelease;

     

       47
       47
       +
             };

     

       48
       48
       +
           };

     

       49
       49
       +
         });

     

       50
       50
       +
       }

+25

pkgs/development/compilers/dotnet/fix-aspnetcore-portable-build.patch

···

       1
       1
       +
       From ebc2540f8d0aba2e5ec2f0d5f5889100475ad93e Mon Sep 17 00:00:00 2001

     

       2
       2
       +
       From: David McFarland <corngood@gmail.com>

     

       3
       3
       +
       Date: Mon, 1 Jan 2024 12:45:41 -0400

     

       4
       4
       +
       Subject: [PATCH] fix aspnetcore portable build

     

       5
       5
       +
       

     

       6
       6
       +
       https://github.com/dotnet/installer/pull/15163#issuecomment-1873396096

     

       7
       7
       +
       ---

     

       8
       8
       +
        repo-projects/aspnetcore.proj | 1 +

     

       9
       9
       +
        1 file changed, 1 insertion(+)

     

       10
       10
       +
       

     

       11
       11
       +
       diff --git a/repo-projects/aspnetcore.proj b/repo-projects/aspnetcore.proj

     

       12
       12
       +
       index e3f4b1664a..947532add9 100644

     

       13
       13
       +
       --- a/repo-projects/aspnetcore.proj

     

       14
       14
       +
       +++ b/repo-projects/aspnetcore.proj

     

       15
       15
       +
       @@ -8,6 +8,7 @@

     

       16
       16
       +
            <OverrideTargetRid Condition="'$(TargetOS)' == 'Windows_NT'">win-$(Platform)</OverrideTargetRid>

     

       17
       17
       +
            <_portableRidOverridden Condition="'$(TargetRid)' != '$(OverrideTargetRid)'">true</_portableRidOverridden>

     

       18
       18
       +
            <_portableRidOverridden Condition="'$(TargetRid)' == '$(OverrideTargetRid)'">false</_portableRidOverridden>

     

       19
       19
       +
       +    <_portableRidOverridden Condition="'$(PortableBuild)' != ''">$(PortableBuild)</_portableRidOverridden>

     

       20
       20
       +
        

     

       21
       21
       +
            <!-- StandardSourceBuildArgs include -publish which is not supported by the aspnetcore build script. -->

     

       22
       22
       +
            <BuildCommandArgs>$(StandardSourceBuildArgs.Replace('--publish', ''))</BuildCommandArgs>

     

       23
       23
       +
       -- 

     

       24
       24
       +
       2.40.1

     

       25
       25
       +

+27

pkgs/development/compilers/dotnet/fix-tmp-path.patch

···

       1
       1
       +
       From e0bd79c04c3647dd5abec5e60c031b1f2762a84c Mon Sep 17 00:00:00 2001

     

       2
       2
       +
       From: David McFarland <corngood@gmail.com>

     

       3
       3
       +
       Date: Wed, 10 Jan 2024 02:25:46 -0400

     

       4
       4
       +
       Subject: [PATCH] fix-tmp-path

     

       5
       5
       +
       

     

       6
       6
       +
       ---

     

       7
       7
       +
        build.sh | 4 ++--

     

       8
       8
       +
        1 file changed, 2 insertions(+), 2 deletions(-)

     

       9
       9
       +
       

     

       10
       10
       +
       diff --git a/build.sh b/build.sh

     

       11
       11
       +
       index a1224e4369..555a88fc95 100755

     

       12
       12
       +
       --- a/build.sh

     

       13
       13
       +
       +++ b/build.sh

     

       14
       14
       +
       @@ -211,8 +211,8 @@ elif [ -d "$packagesArchiveDir" ]; then

     

       15
       15
       +
          if [ -f "${packagesPreviouslySourceBuiltDir}}PackageVersions.props" ]; then

     

       16
       16
       +
            packageVersionsPath=${packagesPreviouslySourceBuiltDir}PackageVersions.props

     

       17
       17
       +
          elif [ -f "$sourceBuiltArchive" ]; then

     

       18
       18
       +
       -    tar -xzf "$sourceBuiltArchive" -C /tmp PackageVersions.props

     

       19
       19
       +
       -    packageVersionsPath=/tmp/PackageVersions.props

     

       20
       20
       +
       +    tar -xzf "$sourceBuiltArchive" PackageVersions.props

     

       21
       21
       +
       +    packageVersionsPath=$PWD/PackageVersions.props

     

       22
       22
       +
          fi

     

       23
       23
       +
        fi

     

       24
       24
       +
        

     

       25
       25
       +
       -- 

     

       26
       26
       +
       2.40.1

     

       27
       27
       +

+99

pkgs/development/compilers/dotnet/packages.nix

···

       1
       1
       +
       { stdenv

     

       2
       2
       +
       , callPackage

     

       3
       3
       +
       , vmr

     

       4
       4
       +
       }:

     

       5
       5
       +
       

     

       6
       6
       +
       let

     

       7
       7
       +
         mkCommon = callPackage ./common.nix {};

     

       8
       8
       +
         inherit (vmr) targetRid releaseManifest;

     

       9
       9
       +
       

     

       10
       10
       +
       in {

     

       11
       11
       +
         inherit vmr;

     

       12
       12
       +
         sdk = mkCommon "sdk" rec {

     

       13
       13
       +
           pname = "dotnet-sdk";

     

       14
       14
       +
           version = releaseManifest.sdkVersion;

     

       15
       15
       +
       

     

       16
       16
       +
           src = vmr;

     

       17
       17
       +
           dontUnpack = true;

     

       18
       18
       +
       

     

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

     

       20
       20
       +
       

     

       21
       21
       +
           installPhase = ''

     

       22
       22
       +
             runHook preInstall

     

       23
       23
       +
       

     

       24
       24
       +
             cp -r "$src"/dotnet-sdk-${version}-${targetRid} "$out"

     

       25
       25
       +
             chmod +w "$out"

     

       26
       26
       +
             mkdir "$out"/bin

     

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

     

       28
       28
       +
       

     

       29
       29
       +
             mkdir "$packages"

     

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

     

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

     

       32
       32
       +
       

     

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

     

       34
       34
       +
       

     

       35
       35
       +
             runHook postInstall

     

       36
       36
       +
           '';

     

       37
       37
       +
       

     

       38
       38
       +
           passthru = {

     

       39
       39
       +
             inherit (vmr) icu targetRid updateScript;

     

       40
       40
       +
           };

     

       41
       41
       +
       

     

       42
       42
       +
           meta = vmr.meta // {

     

       43
       43
       +
             mainProgram = "dotnet";

     

       44
       44
       +
           };

     

       45
       45
       +
         };

     

       46
       46
       +
       

     

       47
       47
       +
         runtime = mkCommon "runtime" rec {

     

       48
       48
       +
           pname = "dotnet-runtime";

     

       49
       49
       +
           version = releaseManifest.runtimeVersion;

     

       50
       50
       +
       

     

       51
       51
       +
           src = vmr;

     

       52
       52
       +
           dontUnpack = true;

     

       53
       53
       +
       

     

       54
       54
       +
           outputs = [ "out" ];

     

       55
       55
       +
       

     

       56
       56
       +
           installPhase = ''

     

       57
       57
       +
             runHook preInstall

     

       58
       58
       +
       

     

       59
       59
       +
             cp -r "$src/dotnet-runtime-${version}-${targetRid}" "$out"

     

       60
       60
       +
             chmod +w "$out"

     

       61
       61
       +
             mkdir "$out"/bin

     

       62
       62
       +
             ln -s "$out"/dotnet "$out"/bin/dotnet

     

       63
       63
       +
       

     

       64
       64
       +
             runHook postInstall

     

       65
       65
       +
           '';

     

       66
       66
       +
       

     

       67
       67
       +
           meta = vmr.meta // {

     

       68
       68
       +
             mainProgram = "dotnet";

     

       69
       69
       +
           };

     

       70
       70
       +
         };

     

       71
       71
       +
       

     

       72
       72
       +
         aspnetcore = mkCommon "aspnetcore" rec {

     

       73
       73
       +
           pname = "dotnet-aspnetcore-runtime";

     

       74
       74
       +
           version = releaseManifest.aspnetcoreRuntimeVersion or releaseManifest.runtimeVersion;

     

       75
       75
       +
       

     

       76
       76
       +
           src = vmr;

     

       77
       77
       +
           dontUnpack = true;

     

       78
       78
       +
       

     

       79
       79
       +
           outputs = [ "out" ];

     

       80
       80
       +
       

     

       81
       81
       +
           installPhase = ''

     

       82
       82
       +
             runHook preInstall

     

       83
       83
       +
       

     

       84
       84
       +
             cp -r "$src/dotnet-runtime-${releaseManifest.runtimeVersion}-${targetRid}" "$out"

     

       85
       85
       +
             chmod +w "$out"

     

       86
       86
       +
             mkdir "$out"/bin

     

       87
       87
       +
             ln -s "$out"/dotnet "$out"/bin/dotnet

     

       88
       88
       +
       

     

       89
       89
       +
             chmod +w "$out"/shared

     

       90
       90
       +
             cp -Tr "$src/aspnetcore-runtime-${version}-${targetRid}" "$out"

     

       91
       91
       +
       

     

       92
       92
       +
             runHook postInstall

     

       93
       93
       +
           '';

     

       94
       94
       +
       

     

       95
       95
       +
           meta = vmr.meta // {

     

       96
       96
       +
             mainProgram = "dotnet";

     

       97
       97
       +
           };

     

       98
       98
       +
         };

     

       99
       99
       +
       }

+62

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

···

       1
       1
       +
       { stdenv

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , dotnetCorePackages

     

       4
       4
       +
       , zlib

     

       5
       5
       +
       , curl

     

       6
       6
       +
       , icu

     

       7
       7
       +
       , libunwind

     

       8
       8
       +
       , libuuid

     

       9
       9
       +
       , openssl

     

       10
       10
       +
       , lttng-ust_2_12

     

       11
       11
       +
       , writeShellScriptBin

     

       12
       12
       +
       }:

     

       13
       13
       +
       

     

       14
       14
       +
       let

     

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

     

       16
       16
       +
       

     

       17
       17
       +
         binaryRPath = lib.makeLibraryPath ([

     

       18
       18
       +
           stdenv.cc.cc

     

       19
       19
       +
           zlib

     

       20
       20
       +
           curl

     

       21
       21
       +
           icu

     

       22
       22
       +
           libunwind

     

       23
       23
       +
           libuuid

     

       24
       24
       +
           openssl

     

       25
       25
       +
         ] ++ lib.optional stdenv.isLinux lttng-ust_2_12);

     

       26
       26
       +
       

     

       27
       27
       +
       in writeShellScriptBin "patch-nupkgs" ''

     

       28
       28
       +
         set -euo pipefail

     

       29
       29
       +
         shopt -s nullglob

     

       30
       30
       +
         isELF() {

     

       31
       31
       +
             local fn="$1"

     

       32
       32
       +
             local fd

     

       33
       33
       +
             local magic

     

       34
       34
       +
             exec {fd}< "$fn"

     

       35
       35
       +
             read -r -n 4 -u "$fd" magic

     

       36
       36
       +
             exec {fd}<&-

     

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

     

       38
       38
       +
         }

     

       39
       39
       +
         cd "$1"

     

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

     

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

     

       42
       42
       +
           echo "Patching package $x"

     

       43
       43
       +
           pushd "$x"

     

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

     

       45
       45
       +
             if [[ "$p" != *.nix-patched ]] && isELF "$p"; then

     

       46
       46
       +
               tmp="$p".$$.nix-patched

     

       47
       47
       +
               # if this fails to copy then another process must have patched it

     

       48
       48
       +
               cp --reflink=auto "$p" "$tmp" || continue

     

       49
       49
       +
               echo "Patchelfing $p as $tmp"

     

       50
       50
       +
               patchelf \

     

       51
       51
       +
                 --set-interpreter "${stdenv.cc.bintools.dynamicLinker}" \

     

       52
       52
       +
                 "$tmp" ||:

     

       53
       53
       +
               patchelf \

     

       54
       54
       +
                 --set-rpath "${binaryRPath}" \

     

       55
       55
       +
                 "$tmp" ||:

     

       56
       56
       +
               mv "$tmp" "$p"

     

       57
       57
       +
             fi

     

       58
       58
       +
           done

     

       59
       59
       +
           touch .nix-patched

     

       60
       60
       +
           popd

     

       61
       61
       +
         done

     

       62
       62
       +
       ''

pkgs/development/compilers/dotnet/patch-restored-packages.proj

···

       1
       1
       +
       <Project>

     

       2
       2
       +
         <Target Name="PatchIlasm" AfterTargets="ResolveIlToolPaths">

     

       3
       3
       +
           <Exec Command="patch-nupkgs $(NUGET_PACKAGES) 2>&amp;1"/>

     

       4
       4
       +
         </Target>

     

       5
       5
       +
         <Target Name="PatchCrossgen" AfterTargets="Restore;_PrepareForReadyToRunCompilation;PrepareForCrossGen">

     

       6
       6
       +
           <Exec Command="patch-nupkgs $(NUGET_PACKAGES) 2>&amp;1"/>

     

       7
       7
       +
         </Target>

     

       8
       8
       +
       </Project>

+42

pkgs/development/compilers/dotnet/record-downloaded-packages.patch

···

       1
       1
       +
       From a5a4a77dd77ed5c997bec6519adf7b6be3108af2 Mon Sep 17 00:00:00 2001

     

       2
       2
       +
       From: David McFarland <corngood@gmail.com>

     

       3
       3
       +
       Date: Sun, 31 Dec 2023 01:48:31 -0400

     

       4
       4
       +
       Subject: [PATCH 2/2] record downloaded packages

     

       5
       5
       +
       

     

       6
       6
       +
       ---

     

       7
       7
       +
        .../buildBootstrapPreviouslySB.csproj         |  6 +++++

     

       8
       8
       +
        repo-projects/Directory.Build.targets         | 27 +++++++++++++++++++

     

       9
       9
       +
        2 files changed, 33 insertions(+)

     

       10
       10
       +
       

     

       11
       11
       +
       diff --git a/eng/bootstrap/buildBootstrapPreviouslySB.csproj b/eng/bootstrap/buildBootstrapPreviouslySB.csproj

     

       12
       12
       +
       index d85e32ca76..280c9eaf89 100644

     

       13
       13
       +
       --- a/eng/bootstrap/buildBootstrapPreviouslySB.csproj

     

       14
       14
       +
       +++ b/eng/bootstrap/buildBootstrapPreviouslySB.csproj

     

       15
       15
       +
       @@ -102,6 +102,12 @@

     

       16
       16
       +
            </ItemGroup>

     

       17
       17
       +
          </Target>

     

       18
       18
       +
        

     

       19
       19
       +
       +  <Target Name="NuGetToNix" AfterTargets="Restore">

     

       20
       20
       +
       +    <Exec

     

       21
       21
       +
       +        Command="nuget-to-nix $(RestorePackagesPath) >$(ArchiveDir)deps.nix 2>&amp;1"

     

       22
       22
       +
       +        WorkingDirectory="$(MSBuildProjectDirectory)"/>

     

       23
       23
       +
       +  </Target>

     

       24
       24
       +
       +

     

       25
       25
       +
          <Target Name="BuildBoostrapPreviouslySourceBuilt"

     

       26
       26
       +
                  AfterTargets="Restore"

     

       27
       27
       +
                  DependsOnTargets="GetPackagesToDownload">

     

       28
       28
       +
       diff --git a/repo-projects/Directory.Build.targets b/repo-projects/Directory.Build.targets

     

       29
       29
       +
       index 3fa15da862..afd7b87088 100644

     

       30
       30
       +
       --- a/repo-projects/Directory.Build.targets

     

       31
       31
       +
       +++ b/repo-projects/Directory.Build.targets

     

       32
       32
       +
       @@ -471,6 +497,7 @@

     

       33
       33
       +
            <ItemGroup>

     

       34
       34
       +
              <LogFilesToCopy Include="$(ProjectDirectory)artifacts/**/*.log" />

     

       35
       35
       +
              <LogFilesToCopy Include="$(ProjectDirectory)artifacts/**/*.binlog" />

     

       36
       36
       +
       +      <LogFilesToCopy Include="$(ProjectDirectory)artifacts/**/deps.nix" />

     

       37
       37
       +
              <ObjFilesToCopy Include="$(ProjectDirectory)artifacts/**/project.assets.json" />

     

       38
       38
       +
            </ItemGroup>

     

       39
       39
       +
            <MakeDir Directories="$(BuildLogsDir)" Condition="Exists('$(ProjectDirectory)artifacts')"/>

     

       40
       40
       +
       -- 

     

       41
       41
       +
       2.40.1

     

       42
       42
       +

+13

pkgs/development/compilers/dotnet/record-downloaded-packages.proj

···

       1
       1
       +
       <Project>

     

       2
       2
       +
         <Target Name="NuGetToNix"

     

       3
       3
       +
           BeforeTargets="CopyInnerBuildRestoredPackages">

     

       4
       4
       +
           <ItemGroup>

     

       5
       5
       +
             <_NuGetToNixPackageCache Include="$(ProjectDirectory)artifacts/sb/package-cache/"/>

     

       6
       6
       +
             <_NuGetToNixPackageCache Include="$(ProjectDirectory)artifacts/source-build/self/package-cache/"/>

     

       7
       7
       +
           </ItemGroup>

     

       8
       8
       +
           <Exec

     

       9
       9
       +
             Command="nuget-to-nix '@(_NuGetToNixPackageCache)' >'$(ProjectDirectory)deps.nix' 2>'$(ProjectDirectory)deps.out'"

     

       10
       10
       +
             WorkingDirectory="$(ProjectDirectory)"

     

       11
       11
       +
             Condition="Exists('%(Identity)')"/>

     

       12
       12
       +
         </Target>

     

       13
       13
       +
       </Project>

+10

pkgs/development/compilers/dotnet/sign-apphost.nix

···

       1
       1
       +
       { substituteAll

     

       2
       2
       +
       , callPackage

     

       3
       3
       +
       }:

     

       4
       4
       +
       let

     

       5
       5
       +
         sigtool = callPackage ./sigtool.nix {};

     

       6
       6
       +
       

     

       7
       7
       +
       in substituteAll {

     

       8
       8
       +
         src = ./sign-apphost.proj;

     

       9
       9
       +
         codesign = "${sigtool}/bin/codesign";

     

       10
       10
       +
       }

+11

pkgs/development/compilers/dotnet/sign-apphost.proj

···

       1
       1
       +
       <Project>

     

       2
       2
       +
         <Target Name="SignAppHost" AfterTargets="_CreateAppHost" Condition="'$(AppHostIntermediatePath)' != ''">

     

       3
       3
       +
           <Exec Command='@codesign@ -f -s - "$(AppHostIntermediatePath)" 2>&amp;1'/>

     

       4
       4
       +
         </Target>

     

       5
       5
       +
         <Target Name="UnsignBundle" BeforeTargets="GenerateSingleFileBundle" Condition="'$(PublishedSingleFileName)' != ''">

     

       6
       6
       +
           <Exec Command='@codesign@ --remove-signature "@(FilesToBundle)" 2>&amp;1' Condition="'%(FilesToBundle.RelativePath)' == '$(PublishedSingleFileName)'"/>

     

       7
       7
       +
         </Target>

     

       8
       8
       +
         <Target Name="SignBundle" AfterTargets="GenerateSingleFileBundle" Condition="'$(PublishedSingleFilePath)' != ''">

     

       9
       9
       +
           <Exec Command='@codesign@ -f -s - "$(PublishedSingleFilePath)" 2>&amp;1'/>

     

       10
       10
       +
         </Target>

     

       11
       11
       +
       </Project>

+27

pkgs/development/compilers/dotnet/sigtool.nix

···

       1
       1
       +
       { darwin

     

       2
       2
       +
       , fetchFromGitHub

     

       3
       3
       +
       , makeWrapper

     

       4
       4
       +
       }:

     

       5
       5
       +
       let

     

       6
       6
       +
         cctools = darwin.cctools;

     

       7
       7
       +
       

     

       8
       8
       +
       in darwin.sigtool.overrideAttrs (old: {

     

       9
       9
       +
         # this is a fork of sigtool that supports -v and --remove-signature, which are

     

       10
       10
       +
         # used by the dotnet sdk

     

       11
       11
       +
         src = fetchFromGitHub {

     

       12
       12
       +
           owner = "corngood";

     

       13
       13
       +
           repo = "sigtool";

     

       14
       14
       +
           rev = "new-commands";

     

       15
       15
       +
           sha256 = "sha256-EVM5ZG3sAHrIXuWrnqA9/4pDkJOpWCeBUl5fh0mkK4k=";

     

       16
       16
       +
         };

     

       17
       17
       +
       

     

       18
       18
       +
         nativeBuildInputs = old.nativeBuildInputs or [] ++ [

     

       19
       19
       +
           makeWrapper

     

       20
       20
       +
         ];

     

       21
       21
       +
       

     

       22
       22
       +
         postInstall = old.postInstall or "" + ''

     

       23
       23
       +
           wrapProgram $out/bin/codesign \

     

       24
       24
       +
             --set-default CODESIGN_ALLOCATE \

     

       25
       25
       +
               "${cctools}/bin/${cctools.targetPrefix}codesign_allocate"

     

       26
       26
       +
         '';

     

       27
       27
       +
       })

+126

pkgs/development/compilers/dotnet/stage0.nix

···

       1
       1
       +
       { stdenv

     

       2
       2
       +
       , stdenvNoCC

     

       3
       3
       +
       , callPackage

     

       4
       4
       +
       , lib

     

       5
       5
       +
       , writeShellScript

     

       6
       6
       +
       , pkgsBuildHost

     

       7
       7
       +
       , mkNugetDeps

     

       8
       8
       +
       , nix

     

       9
       9
       +
       , cacert

     

       10
       10
       +
       , nuget-to-nix

     

       11
       11
       +
       , dotnetCorePackages

     

       12
       12
       +
       , xmlstarlet

     

       13
       13
       +
       

     

       14
       14
       +
       , releaseManifestFile

     

       15
       15
       +
       , tarballHash

     

       16
       16
       +
       , depsFile

     

       17
       17
       +
       , bootstrapSdk

     

       18
       18
       +
       }:

     

       19
       19
       +
       

     

       20
       20
       +
       let

     

       21
       21
       +
         mkPackages = callPackage ./packages.nix;

     

       22
       22
       +
         mkVMR = callPackage ./vmr.nix;

     

       23
       23
       +
       

     

       24
       24
       +
         dotnetSdk = pkgsBuildHost.callPackage bootstrapSdk {};

     

       25
       25
       +
       

     

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

     

       27
       27
       +
       

     

       28
       28
       +
         signAppHost = callPackage ./sign-apphost.nix {};

     

       29
       29
       +
       

     

       30
       30
       +
         deps = mkNugetDeps {

     

       31
       31
       +
           name = "dotnet-vmr-deps";

     

       32
       32
       +
           sourceFile = depsFile;

     

       33
       33
       +
         };

     

       34
       34
       +
       

     

       35
       35
       +
         vmr = (mkVMR {

     

       36
       36
       +
           inherit releaseManifestFile tarballHash dotnetSdk;

     

       37
       37
       +
         }).overrideAttrs (old: rec {

     

       38
       38
       +
           prebuiltPackages = mkNugetDeps {

     

       39
       39
       +
             name = "dotnet-vmr-deps";

     

       40
       40
       +
             sourceFile = depsFile;

     

       41
       41
       +
           };

     

       42
       42
       +
       

     

       43
       43
       +
           nativeBuildInputs =

     

       44
       44
       +
             old.nativeBuildInputs or []

     

       45
       45
       +
             ++ [ xmlstarlet ]

     

       46
       46
       +
             ++ lib.optional stdenv.isLinux patchNupkgs;

     

       47
       47
       +
       

     

       48
       48
       +
           postPatch = old.postPatch or "" + lib.optionalString stdenv.isLinux ''

     

       49
       49
       +
             xmlstarlet ed \

     

       50
       50
       +
               --inplace \

     

       51
       51
       +
               -s //Project -t elem -n Import \

     

       52
       52
       +
               -i \$prev -t attr -n Project -v "${./patch-restored-packages.proj}" \

     

       53
       53
       +
               src/*/Directory.Build.targets

     

       54
       54
       +
           '' + lib.optionalString stdenv.isDarwin ''

     

       55
       55
       +
             xmlstarlet ed \

     

       56
       56
       +
               --inplace \

     

       57
       57
       +
               -s //Project -t elem -n Import \

     

       58
       58
       +
               -i \$prev -t attr -n Project -v "${signAppHost}" \

     

       59
       59
       +
               src/runtime/Directory.Build.targets

     

       60
       60
       +
           '';

     

       61
       61
       +
       

     

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

     

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

     

       64
       64
       +
           '';

     

       65
       65
       +
       

     

       66
       66
       +
           passthru = old.passthru or {} // { fetch-deps =

     

       67
       67
       +
             let

     

       68
       68
       +
               inherit (vmr) targetRid updateScript;

     

       69
       69
       +
               otherRids =

     

       70
       70
       +
                 lib.remove targetRid (

     

       71
       71
       +
                   map (system: dotnetCorePackages.systemToDotnetRid system)

     

       72
       72
       +
                     vmr.meta.platforms);

     

       73
       73
       +
       

     

       74
       74
       +
               pkg = vmr.overrideAttrs (old: {

     

       75
       75
       +
                 nativeBuildInputs = old.nativeBuildInputs ++ [

     

       76
       76
       +
                   nix

     

       77
       77
       +
                   cacert

     

       78
       78
       +
                   (nuget-to-nix.override { dotnet-sdk = dotnetSdk; })

     

       79
       79
       +
                 ];

     

       80
       80
       +
                 postPatch = old.postPatch or "" + ''

     

       81
       81
       +
                   xmlstarlet ed \

     

       82
       82
       +
                     --inplace \

     

       83
       83
       +
                     -s //Project -t elem -n Import \

     

       84
       84
       +
                     -i \$prev -t attr -n Project -v "${./record-downloaded-packages.proj}" \

     

       85
       85
       +
                     repo-projects/Directory.Build.targets

     

       86
       86
       +
                   # make nuget-client use the standard arcade package-cache dir, which

     

       87
       87
       +
                   # is where we scan for dependencies

     

       88
       88
       +
                   xmlstarlet ed \

     

       89
       89
       +
                     --inplace \

     

       90
       90
       +
                     -s //Project -t elem -n ItemGroup \

     

       91
       91
       +
                     -s \$prev -t elem -n EnvironmentVariables \

     

       92
       92
       +
                     -i \$prev -t attr -n Include -v 'NUGET_PACKAGES=$(ProjectDirectory)artifacts/sb/package-cache/' \

     

       93
       93
       +
                     repo-projects/nuget-client.proj

     

       94
       94
       +
                 '';

     

       95
       95
       +
                 buildFlags = [ "--online" ] ++ old.buildFlags;

     

       96
       96
       +
                 prebuiltPackages = null;

     

       97
       97
       +
               });

     

       98
       98
       +
       

     

       99
       99
       +
               drv = builtins.unsafeDiscardOutputDependency pkg.drvPath;

     

       100
       100
       +
             in

     

       101
       101
       +
               writeShellScript "fetch-dotnet-sdk-deps" ''

     

       102
       102
       +
                 ${nix}/bin/nix-shell --pure --run 'source /dev/stdin' "${drv}" << 'EOF'

     

       103
       103
       +
                 set -e

     

       104
       104
       +
       

     

       105
       105
       +
                 tmp=$(mktemp -d)

     

       106
       106
       +
                 trap 'rm -fr "$tmp"' EXIT

     

       107
       107
       +
       

     

       108
       108
       +
                 HOME=$tmp/.home

     

       109
       109
       +
                 cd "$tmp"

     

       110
       110
       +
       

     

       111
       111
       +
                 phases="''${prePhases[*]:-} unpackPhase patchPhase ''${preConfigurePhases[*]:-} \

     

       112
       112
       +
                   configurePhase ''${preBuildPhases[*]:-} buildPhase checkPhase" \

     

       113
       113
       +
                   genericBuild

     

       114
       114
       +
       

     

       115
       115
       +
                 depsFiles=(./src/*/deps.nix)

     

       116
       116
       +
       

     

       117
       117
       +
                 cat $(nix-build ${toString ./combine-deps.nix} \

     

       118
       118
       +
                   --arg list "[ ''${depsFiles[*]} ]" \

     

       119
       119
       +
                   --argstr baseRid ${targetRid} \

     

       120
       120
       +
                   --arg otherRids '${lib.generators.toPretty { multiline = false; } otherRids}' \

     

       121
       121
       +
                   ) > "${toString prebuiltPackages.sourceFile}"

     

       122
       122
       +
                 EOF

     

       123
       123
       +
               '';

     

       124
       124
       +
           };

     

       125
       125
       +
         });

     

       126
       126
       +
       in mkPackages { inherit vmr; }

+27

pkgs/development/compilers/dotnet/stage1.nix

···

       1
       1
       +
       { stdenv

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , callPackage

     

       4
       4
       +
       , pkgsBuildHost

     

       5
       5
       +
       

     

       6
       6
       +
       , releaseManifestFile

     

       7
       7
       +
       , tarballHash

     

       8
       8
       +
       , depsFile

     

       9
       9
       +
       , bootstrapSdk

     

       10
       10
       +
       }@args:

     

       11
       11
       +
       

     

       12
       12
       +
       let

     

       13
       13
       +
         mkPackages = callPackage ./packages.nix;

     

       14
       14
       +
         mkVMR = callPackage ./vmr.nix;

     

       15
       15
       +
       

     

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

     

       17
       17
       +
       

     

       18
       18
       +
         vmr = (mkVMR {

     

       19
       19
       +
           inherit releaseManifestFile tarballHash;

     

       20
       20
       +
           dotnetSdk = stage0.sdk;

     

       21
       21
       +
         }).overrideAttrs (old: {

     

       22
       22
       +
           passthru = old.passthru or {} // {

     

       23
       23
       +
             inherit (stage0.vmr) fetch-deps;

     

       24
       24
       +
           };

     

       25
       25
       +
         });

     

       26
       26
       +
       

     

       27
       27
       +
       in mkPackages { inherit vmr; }

+31

pkgs/development/compilers/dotnet/stop-passing-bare-sdk-arg-to-swiftc.patch

···

       1
       1
       +
       From 85a940f3f039704da73ee177c1848cd4b6ed029f Mon Sep 17 00:00:00 2001

     

       2
       2
       +
       From: David McFarland <corngood@gmail.com>

     

       3
       3
       +
       Date: Tue, 9 Jan 2024 15:10:00 -0400

     

       4
       4
       +
       Subject: [PATCH] stop passing bare sdk arg to swiftc

     

       5
       5
       +
       

     

       6
       6
       +
       ---

     

       7
       7
       +
        .../CMakeLists.txt                                          | 6 +++++-

     

       8
       8
       +
        1 file changed, 5 insertions(+), 1 deletion(-)

     

       9
       9
       +
       

     

       10
       10
       +
       diff --git a/src/runtime/src/native/libs/System.Security.Cryptography.Native.Apple/CMakeLists.txt b/src/runtime/src/native/libs/System.Security.Cryptography.Native.Apple/CMakeLists.txt

     

       11
       11
       +
       index b847f5c3cd..cf8344ead0 100644

     

       12
       12
       +
       --- a/src/runtime/src/native/libs/System.Security.Cryptography.Native.Apple/CMakeLists.txt

     

       13
       13
       +
       +++ b/src/runtime/src/native/libs/System.Security.Cryptography.Native.Apple/CMakeLists.txt

     

       14
       14
       +
       @@ -49,9 +49,13 @@ if (NOT SWIFT_COMPILER_TARGET AND CLR_CMAKE_TARGET_OSX)

     

       15
       15
       +
            set(SWIFT_COMPILER_TARGET "${CMAKE_OSX_ARCHITECTURES}-apple-${SWIFT_PLATFORM}${SWIFT_DEPLOYMENT_TARGET}${SWIFT_PLATFORM_SUFFIX}")

     

       16
       16
       +
        endif()

     

       17
       17
       +
        

     

       18
       18
       +
       +if (CMAKE_OSX_SYSROOT)

     

       19
       19
       +
       +    set(SWIFT_ARGS -sdk ${CMAKE_OSX_SYSROOT})

     

       20
       20
       +
       +endif()

     

       21
       21
       +
       +

     

       22
       22
       +
        add_custom_command(

     

       23
       23
       +
            OUTPUT pal_swiftbindings.o

     

       24
       24
       +
       -    COMMAND xcrun swiftc -emit-object -static -parse-as-library -runtime-compatibility-version none -sdk ${CMAKE_OSX_SYSROOT} -target ${SWIFT_COMPILER_TARGET} ${CMAKE_CURRENT_SOURCE_DIR}/pal_swiftbindings.swift -o pal_swiftbindings.o

     

       25
       25
       +
       +    COMMAND xcrun swiftc -emit-object -static -parse-as-library -runtime-compatibility-version none ${SWIFT_ARGS} -target ${SWIFT_COMPILER_TARGET} ${CMAKE_CURRENT_SOURCE_DIR}/pal_swiftbindings.swift -o pal_swiftbindings.o

     

       26
       26
       +
            MAIN_DEPENDENCY ${CMAKE_CURRENT_SOURCE_DIR}/pal_swiftbindings.swift

     

       27
       27
       +
            COMMENT "Compiling Swift file pal_swiftbindings.swift"

     

       28
       28
       +
        )

     

       29
       29
       +
       -- 

     

       30
       30
       +
       2.42.0

     

       31
       31
       +

+123

pkgs/development/compilers/dotnet/update.nix

···

       1
       1
       +
       { stdenvNoCC

     

       2
       2
       +
       , lib

     

       3
       3
       +
       , fetchurl

     

       4
       4
       +
       , writeScript

     

       5
       5
       +
       , nix

     

       6
       6
       +
       , runtimeShell

     

       7
       7
       +
       , curl

     

       8
       8
       +
       , cacert

     

       9
       9
       +
       , jq

     

       10
       10
       +
       , yq

     

       11
       11
       +
       , gnupg

     

       12
       12
       +
       

     

       13
       13
       +
       , releaseManifestFile

     

       14
       14
       +
       , releaseInfoFile

     

       15
       15
       +
       , allowPrerelease

     

       16
       16
       +
       }:

     

       17
       17
       +
       

     

       18
       18
       +
       let

     

       19
       19
       +
         inherit (lib.importJSON releaseManifestFile) channel release;

     

       20
       20
       +
       

     

       21
       21
       +
         pkg = stdenvNoCC.mkDerivation {

     

       22
       22
       +
           name = "update-dotnet-vmr-env";

     

       23
       23
       +
       

     

       24
       24
       +
           nativeBuildInputs = [

     

       25
       25
       +
             nix

     

       26
       26
       +
             curl

     

       27
       27
       +
             cacert

     

       28
       28
       +
             jq

     

       29
       29
       +
             yq

     

       30
       30
       +
             gnupg

     

       31
       31
       +
           ];

     

       32
       32
       +
         };

     

       33
       33
       +
       

     

       34
       34
       +
         releaseKey = fetchurl {

     

       35
       35
       +
           url = "https://dotnet.microsoft.com/download/dotnet/release-key-2023.asc";

     

       36
       36
       +
           hash = "sha256-F668QB55md0GQvoG0jeA66Fb2RbrsRhFTzTbXIX3GUo=";

     

       37
       37
       +
         };

     

       38
       38
       +
       

     

       39
       39
       +
         drv = builtins.unsafeDiscardOutputDependency pkg.drvPath;

     

       40
       40
       +
       

     

       41
       41
       +
       in writeScript "update-dotnet-vmr.sh" ''

     

       42
       42
       +
         #! ${nix}/bin/nix-shell

     

       43
       43
       +
         #! nix-shell -i ${runtimeShell} --pure ${drv}

     

       44
       44
       +
         set -euo pipefail

     

       45
       45
       +
       

     

       46
       46
       +
         query=$(cat <<EOF

     

       47
       47
       +
             map(

     

       48
       48
       +
                 select(

     

       49
       49
       +
                     ${lib.optionalString (!allowPrerelease) ".prerelease == false and"}

     

       50
       50
       +
                     .draft == false and

     

       51
       51
       +
                     (.name | startswith(".NET ${channel}")))) |

     

       52
       52
       +
             first | (

     

       53
       53
       +
                 .name,

     

       54
       54
       +
                 .tag_name,

     

       55
       55
       +
                 (.assets |

     

       56
       56
       +
                     .[] |

     

       57
       57
       +
                     select(.name == "release.json") |

     

       58
       58
       +
                     .browser_download_url),

     

       59
       59
       +
                 (.assets |

     

       60
       60
       +
                     .[] |

     

       61
       61
       +
                     select(.name | endswith(".tar.gz.sig")) |

     

       62
       62
       +
                     .browser_download_url))

     

       63
       63
       +
         EOF

     

       64
       64
       +
         )

     

       65
       65
       +
       

     

       66
       66
       +
         (

     

       67
       67
       +
             curl -fsL https://api.github.com/repos/dotnet/dotnet/releases | \

     

       68
       68
       +
             jq -r "$query" \

     

       69
       69
       +
         ) | (

     

       70
       70
       +
             read name

     

       71
       71
       +
             read tagName

     

       72
       72
       +
             read releaseUrl

     

       73
       73
       +
             read sigUrl

     

       74
       74
       +
       

     

       75
       75
       +
             if [[ "$name" == ".NET ${release}" ]]; then

     

       76
       76
       +
                 >&2 echo "release is already $name"

     

       77
       77
       +
                 exit

     

       78
       78
       +
             fi

     

       79
       79
       +
       

     

       80
       80
       +
             tmp="$(mktemp -d)"

     

       81
       81
       +
             trap 'rm -rf "$tmp"' EXIT

     

       82
       82
       +
       

     

       83
       83
       +
             tarballUrl=https://github.com/dotnet/dotnet/archive/refs/tags/$tagName.tar.gz

     

       84
       84
       +
       

     

       85
       85
       +
             mapfile -t prefetch < <(nix-prefetch-url --print-path "$tarballUrl")

     

       86
       86
       +
             tarballHash=$(nix-hash --to-sri --type sha256 "''${prefetch[0]}")

     

       87
       87
       +
             tarball=''${prefetch[1]}

     

       88
       88
       +
       

     

       89
       89
       +
             cd "$tmp"

     

       90
       90
       +
             curl -L "$sigUrl" -o release.sig

     

       91
       91
       +
       

     

       92
       92
       +
             export GNUPGHOME=$PWD/.gnupg

     

       93
       93
       +
             gpg --batch --import ${releaseKey}

     

       94
       94
       +
             gpg --batch --verify release.sig "$tarball"

     

       95
       95
       +
       

     

       96
       96
       +
             tar --strip-components=1 --no-wildcards-match-slash --wildcards -xzf "$tarball" \*/eng/Versions.props

     

       97
       97
       +
             artifactsVersion=$(xq -r '.Project.PropertyGroup |

     

       98
       98
       +
                 map(select(.PrivateSourceBuiltArtifactsVersion))

     

       99
       99
       +
                 | .[] | .PrivateSourceBuiltArtifactsVersion' eng/Versions.props)

     

       100
       100
       +
       

     

       101
       101
       +
             if [[ "$artifactsVersion" != "" ]]; then

     

       102
       102
       +
                 artifactsUrl=https://dotnetcli.azureedge.net/source-built-artifacts/assets/Private.SourceBuilt.Artifacts.$artifactsVersion.centos.8-x64.tar.gz

     

       103
       103
       +
             else

     

       104
       104
       +
                 artifactsUrl=$(xq -r '.Project.PropertyGroup |

     

       105
       105
       +
                     map(select(.PrivateSourceBuiltArtifactsUrl))

     

       106
       106
       +
                     | .[] | .PrivateSourceBuiltArtifactsUrl' eng/Versions.props)

     

       107
       107
       +
             fi

     

       108
       108
       +
       

     

       109
       109
       +
             artifactsHash=$(nix-hash --to-sri --type sha256 "$(nix-prefetch-url "$artifactsUrl")")

     

       110
       110
       +
       

     

       111
       111
       +
             jq --null-input \

     

       112
       112
       +
                 --arg _0 "$tarballHash" \

     

       113
       113
       +
                 --arg _1 "$artifactsUrl" \

     

       114
       114
       +
                 --arg _2 "$artifactsHash" \

     

       115
       115
       +
                 '{

     

       116
       116
       +
                     "tarballHash": $_0,

     

       117
       117
       +
                     "artifactsUrl": $_1,

     

       118
       118
       +
                     "artifactsHash": $_2,

     

       119
       119
       +
                 }' > "${toString releaseInfoFile}"

     

       120
       120
       +
       

     

       121
       121
       +
             curl -fsL "$releaseUrl" -o ${toString releaseManifestFile}

     

       122
       122
       +
         )

     

       123
       123
       +
       ''

+179

pkgs/development/compilers/dotnet/versions/8.0.102.nix

···

       1
       1
       +
       { buildAspNetCore, buildNetRuntime, buildNetSdk }:

     

       2
       2
       +
       

     

       3
       3
       +
       # v8.0 (active)

     

       4
       4
       +
       {

     

       5
       5
       +
         aspnetcore_8_0 = buildAspNetCore {

     

       6
       6
       +
           version = "8.0.2";

     

       7
       7
       +
           srcs = {

     

       8
       8
       +
             x86_64-linux = {

     

       9
       9
       +
               url     = "https://download.visualstudio.microsoft.com/download/pr/d6d79cc3-df2f-4680-96ff-a7198f461139/df025000eaf5beb85d9137274a8c53ea/aspnetcore-runtime-8.0.2-linux-x64.tar.gz";

     

       10
       10
       +
               sha512  = "c8d4f9ad45cc97570ac607c0d14064da6c1215ef864afd73688ec7470af774f80504a937cbb5aadbb0083250122aae361770d2bca68f30ac7b62b4717bee6fca";

     

       11
       11
       +
             };

     

       12
       12
       +
             aarch64-linux = {

     

       13
       13
       +
               url     = "https://download.visualstudio.microsoft.com/download/pr/bdfd0216-539e-4dfd-81ea-1b7a77dda929/59a62884bdb8684ef0e4f434eaea0ca3/aspnetcore-runtime-8.0.2-linux-arm64.tar.gz";

     

       14
       14
       +
               sha512  = "9e5733a0d40705df17a1c96025783fd2544ad344ac98525f9d11947ea6ef632a23b0d2bf536314e4aeda8ae9c0f65b8f8feee184e1a1aabfda30059f59b1b9a6";

     

       15
       15
       +
             };

     

       16
       16
       +
             x86_64-darwin = {

     

       17
       17
       +
               url     = "https://download.visualstudio.microsoft.com/download/pr/a44da2c3-cb74-4ffe-af5a-34286598a885/263f113228e88df3f654510c9092f68b/aspnetcore-runtime-8.0.2-osx-x64.tar.gz";

     

       18
       18
       +
               sha512  = "a7edf091509305d27275d5d7911c3c61a2546e0d3b5b0fe9fcb9e704daf3c550ea0a5ae659272a29b5e218d02f28b7d331ab0905e9459711624692f1589d7285";

     

       19
       19
       +
             };

     

       20
       20
       +
             aarch64-darwin = {

     

       21
       21
       +
               url     = "https://download.visualstudio.microsoft.com/download/pr/a5692569-6092-4db1-9d5c-4862265a7b5b/7173de926da466e21ab9c7666a31dee3/aspnetcore-runtime-8.0.2-osx-arm64.tar.gz";

     

       22
       22
       +
               sha512  = "9e79556cf58f9d0b0f302a50ef9724122a9b18daba70e715b7334f9ed97a4983be0386e4132f5273d120f00d18f8af8a8ad7ea1ef0a82c610e268a33e76a30e4";

     

       23
       23
       +
             };

     

       24
       24
       +
           };

     

       25
       25
       +
         };

     

       26
       26
       +
       

     

       27
       27
       +
         runtime_8_0 = buildNetRuntime {

     

       28
       28
       +
           version = "8.0.2";

     

       29
       29
       +
           srcs = {

     

       30
       30
       +
             x86_64-linux = {

     

       31
       31
       +
               url     = "https://download.visualstudio.microsoft.com/download/pr/307e4bf7-53c1-4b03-a2e5-379151ab3a04/140e7502609d45dfd83e4750b4bb5178/dotnet-runtime-8.0.2-linux-x64.tar.gz";

     

       32
       32
       +
               sha512  = "f30f72f55b9e97e36107f920e932477183867726a963ea0d4d151f291981877ba253a7175614c60b386b6a37f9192d97d7402dafdad2529369f512698cb9d1dd";

     

       33
       33
       +
             };

     

       34
       34
       +
             aarch64-linux = {

     

       35
       35
       +
               url     = "https://download.visualstudio.microsoft.com/download/pr/9de452db-acbe-48eb-b3f0-305a4e48e32a/515bbe7e3e1deef5ab9a4b8123b901ca/dotnet-runtime-8.0.2-linux-arm64.tar.gz";

     

       36
       36
       +
               sha512  = "12c5f49b7bd63d73cae57949e1520eaebc47732f559f68199ecd3bcca597f2da702352313a20aa100c667ede1d701dc6822f7a4eee9063d1c73d1f451ed832ac";

     

       37
       37
       +
             };

     

       38
       38
       +
             x86_64-darwin = {

     

       39
       39
       +
               url     = "https://download.visualstudio.microsoft.com/download/pr/414af43f-fdc6-4e8e-bbff-8b544a6627a8/0719a2eafa1d0d5f73ee0a7aae4ce670/dotnet-runtime-8.0.2-osx-x64.tar.gz";

     

       40
       40
       +
               sha512  = "e8945057f5fdf55994675caeff07ff53ba96324edbfe148ea60f58c883548be59cd1d891552b55ed5a594c1cfa549bd783ce9e25b5467ae48ab3f97590f36003";

     

       41
       41
       +
             };

     

       42
       42
       +
             aarch64-darwin = {

     

       43
       43
       +
               url     = "https://download.visualstudio.microsoft.com/download/pr/c7b73f69-39ca-4d2a-bd02-a72abb3a4fc5/6d68aa25f4576b70fff4925fb4e69c4b/dotnet-runtime-8.0.2-osx-arm64.tar.gz";

     

       44
       44
       +
               sha512  = "c410f56283f0d51484d26755349a7b62364e2c54650c87dcee6fea0a370fa84b14b4ebc8c5e121e2b3ea4f0ac2880ebe40a43bcb02aa30ce360fd0dbc12fbfbb";

     

       45
       45
       +
             };

     

       46
       46
       +
           };

     

       47
       47
       +
         };

     

       48
       48
       +
       

     

       49
       49
       +
         sdk_8_0 = buildNetSdk {

     

       50
       50
       +
           version = "8.0.102";

     

       51
       51
       +
           srcs = {

     

       52
       52
       +
             x86_64-linux = {

     

       53
       53
       +
               url     = "https://download.visualstudio.microsoft.com/download/pr/672cfd95-c7fe-42e3-8b68-30c74f7af88e/ecdaa65fe42b6572ed37d407c26de8a2/dotnet-sdk-8.0.102-linux-x64.tar.gz";

     

       54
       54
       +
               sha512  = "f5928f5b947441065f2f34b25ae8de1fbf7dbae2c0ba918bfb4224d2d08849c79cbdc1825c0d42a5822f12757f78efa58e295a8ee0f0e6fce39cc7c6ed977b8f";

     

       55
       55
       +
             };

     

       56
       56
       +
             aarch64-linux = {

     

       57
       57
       +
               url     = "https://download.visualstudio.microsoft.com/download/pr/23568042-614a-41d3-a6b9-51e178e42977/cb1e1f4f5fb5d46080a60cd14d631660/dotnet-sdk-8.0.102-linux-arm64.tar.gz";

     

       58
       58
       +
               sha512  = "5e0b5762ab2f038de50859a2e18a3964ea6b754faa01d72f9824100546a271148908e84d666bb63d25e5d9a92038bc8a2f944d0342bbf8834cb5d5e936878c76";

     

       59
       59
       +
             };

     

       60
       60
       +
             x86_64-darwin = {

     

       61
       61
       +
               url     = "https://download.visualstudio.microsoft.com/download/pr/e60574bc-0bb6-45c6-ad3f-5c5fa29c75b7/1d903893164d767b98e9998153ed4c88/dotnet-sdk-8.0.102-osx-x64.tar.gz";

     

       62
       62
       +
               sha512  = "963432c5c7d7d0b204a92248c61d1be227369c6bc1d47f977c913c416c61584451fd05d0e95a6fbe51f0e1958e1c1a71f2530f478dd036ed2b0e123944b3ce00";

     

       63
       63
       +
             };

     

       64
       64
       +
             aarch64-darwin = {

     

       65
       65
       +
               url     = "https://download.visualstudio.microsoft.com/download/pr/e89e4d12-89c6-419c-a2be-9b2ec96b209f/0f393a6b611b26d7e4599694dff857e2/dotnet-sdk-8.0.102-osx-arm64.tar.gz";

     

       66
       66
       +
               sha512  = "69d702b561ae7ddf4c47fe228c16472fd8d7065de1a4a206fc07c6906db49e7da25b21c06f0ef080f41658aeddc0f3c0a23ce1de7e65b830c308bfe13cf95fe8";

     

       67
       67
       +
             };

     

       68
       68
       +
           };

     

       69
       69
       +
           packages = { fetchNuGet }: [

     

       70
       70
       +
             (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.linux-arm"; version = "8.0.2"; sha256 = "06s21b9k4niwb2qlrz4faccfmqyxfv08vzd85izla3zjxmqv3jxb"; })

     

       71
       71
       +
             (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.linux-arm64"; version = "8.0.2"; sha256 = "1bxsrlsyvia4v3fswxl9pnf9107zwf1n1hlwffyxs0kd5iq7jabr"; })

     

       72
       72
       +
             (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.linux-musl-arm64"; version = "8.0.2"; sha256 = "14yysn896flzsisnc3bhfc98slj2xg3f5jr39m62w2p54km0jcrj"; })

     

       73
       73
       +
             (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.linux-musl-x64"; version = "8.0.2"; sha256 = "1486lnpn9al764f4q9p2xry38qrk1127m62j5n8ikcx8iazrbkqm"; })

     

       74
       74
       +
             (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.linux-x64"; version = "8.0.2"; sha256 = "0fh2lvjrl41r1r4q3v9mylr16arb190x4xs0m5nsg6qak93y6pip"; })

     

       75
       75
       +
             (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.osx-x64"; version = "8.0.2"; sha256 = "0ihhhsypb0f8lffl5lbm4nw0l9cwcv6dgylxbgvs10yfpvpix8av"; })

     

       76
       76
       +
             (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.win-arm64"; version = "8.0.2"; sha256 = "1pfwb7j3gg62z10k799w2hr8yqmiv9gjvqzw6g72navzk322901s"; })

     

       77
       77
       +
             (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.win-x64"; version = "8.0.2"; sha256 = "0anifybcb7yipazd0qsiz6g1kj7liw6qz3lmqhkw3ipbr0zip0vv"; })

     

       78
       78
       +
             (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.win-x86"; version = "8.0.2"; sha256 = "0ag84bb4p9w41njyf7yh5h2wgz49qgx1xzhb6q4ls0m03mknp2g6"; })

     

       79
       79
       +
             (fetchNuGet { pname = "Microsoft.AspNetCore.App.Ref"; version = "8.0.2"; sha256 = "1iv12b2pdngn9pzd9cx0n7v3q6dsw8c38vx1ypd6fb27qqwrdrr6"; })

     

       80
       80
       +
             (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.linux-musl-arm"; version = "8.0.2"; sha256 = "1a0zy0sfd4k7pwwk7fkgyd4vph91nfbxhjzvha96ravdh8isxngx"; })

     

       81
       81
       +
             (fetchNuGet { pname = "Microsoft.AspNetCore.App.Runtime.osx-arm64"; version = "8.0.2"; sha256 = "0xfwnqbbzg1xb6zxlms5v1dj3jh46lh6vzfjbqxj55fj87qr73yi"; })

     

       82
       82
       +
             (fetchNuGet { pname = "Microsoft.NETCore.App.Host.linux-arm"; version = "8.0.2"; sha256 = "1217mw4mw978f2d84h0vf0bbzl55kp8z1n4620rphqh6l4r1gr52"; })

     

       83
       83
       +
             (fetchNuGet { pname = "Microsoft.NETCore.App.Host.linux-arm64"; version = "8.0.2"; sha256 = "1pi4s9sn64cyvarba1vgb17k92ank7q95xmn7dz9zb1z9n6v19hm"; })

     

       84
       84
       +
             (fetchNuGet { pname = "Microsoft.NETCore.App.Host.linux-musl-arm64"; version = "8.0.2"; sha256 = "13ckd4w7ysa5ay5wmklsnws7hhzw6nnlblhcda7r11m0fjfly6lr"; })

     

       85
       85
       +
             (fetchNuGet { pname = "Microsoft.NETCore.App.Host.linux-musl-x64"; version = "8.0.2"; sha256 = "0vy2r79sgr6p665943rb44d1m5xv8m6h96rqlr03g6ipk1gzz6xw"; })

     

       86
       86
       +
             (fetchNuGet { pname = "Microsoft.NETCore.App.Host.linux-x64"; version = "8.0.2"; sha256 = "1kbdpqfq64h3dy2mj90sfi2pjks77fmp74fqkvps35fh3lacb3dq"; })

     

       87
       87
       +
             (fetchNuGet { pname = "Microsoft.NETCore.App.Host.osx-x64"; version = "8.0.2"; sha256 = "1xlnlp4ckqn0myl5pzsqhmpall1pnbmqhb62rr7m61dy83xhvm6l"; })

     

       88
       88
       +
             (fetchNuGet { pname = "Microsoft.NETCore.App.Host.win-arm64"; version = "8.0.2"; sha256 = "131kgy0787a38zmb3y002yr1lrnkfc4mk2xmh8jx5pqkl7bp5p67"; })

     

       89
       89
       +
             (fetchNuGet { pname = "Microsoft.NETCore.App.Host.win-x64"; version = "8.0.2"; sha256 = "1p7152v1wyhrxh1mqq29bm06xcfilzngr89cl8kxv5lcars3yc00"; })

     

       90
       90
       +
             (fetchNuGet { pname = "Microsoft.NETCore.App.Host.win-x86"; version = "8.0.2"; sha256 = "0yyix9cypm53b0q6zfw5bqbm18x2s54ns7a1w7apxfzs8cckjfp7"; })

     

       91
       91
       +
             (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.linux-arm"; version = "8.0.2"; sha256 = "0j31y9qwcm76zsxbid52zn4350sbq489pa7znmkzdrxgbcn19dmq"; })

     

       92
       92
       +
             (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.linux-arm64"; version = "8.0.2"; sha256 = "1g2n69s8sa9ik9jhkc6xcdjcvghwr5m9glbxr1f22dbj6nw433c4"; })

     

       93
       93
       +
             (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.linux-musl-arm64"; version = "8.0.2"; sha256 = "0h148hmzrplhw2cx9yd2jmrw6ilpc9ys98w6jcaphzb7n184y374"; })

     

       94
       94
       +
             (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.linux-musl-x64"; version = "8.0.2"; sha256 = "1xcfs5yxsxis9hx1dkp5bkhgl0n95ja2ibwwnxmg2agc8134y935"; })

     

       95
       95
       +
             (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.linux-x64"; version = "8.0.2"; sha256 = "0zvivfiz8lja1k6vcmwswh4lz6ch8x0nlap3x35psfw3p7j51163"; })

     

       96
       96
       +
             (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.osx-x64"; version = "8.0.2"; sha256 = "0x3fsfkv2gcilhsj31pjgg2vfibq2xvqhprw3hpm4gig4c2qi4fg"; })

     

       97
       97
       +
             (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.win-arm64"; version = "8.0.2"; sha256 = "1w6bads6vyiikbfds95zpw91qmb87a20my67c5pri3q6qqwcny6d"; })

     

       98
       98
       +
             (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.win-x64"; version = "8.0.2"; sha256 = "1cfd2bq41y3m86528hxlh3cj975rvhj8gigalfxaw5jsv8hw6cdm"; })

     

       99
       99
       +
             (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.win-x86"; version = "8.0.2"; sha256 = "0s92zdr0midkjk5xip0l3s8md7gcfh4dz81pqz2p7wwhcm29k1hq"; })

     

       100
       100
       +
             (fetchNuGet { pname = "Microsoft.NETCore.DotNetAppHost"; version = "8.0.2"; sha256 = "0c99m8sh056wkk7h3f9bj8l67dxwzwnmz0ix398ff1w1pdpiabcm"; })

     

       101
       101
       +
             (fetchNuGet { pname = "Microsoft.NETCore.DotNetHost"; version = "8.0.2"; sha256 = "13l2xa4fxnm6i6kpjwr173hyd61s2ks7sjzp2ah3l1n71wds3vag"; })

     

       102
       102
       +
             (fetchNuGet { pname = "Microsoft.NETCore.DotNetHostPolicy"; version = "8.0.2"; sha256 = "16qhn61di7gz5a68sc2rg5y2y4293rsbks4rvplyjr68scnba4hb"; })

     

       103
       103
       +
             (fetchNuGet { pname = "Microsoft.NETCore.DotNetHostResolver"; version = "8.0.2"; sha256 = "0mz7h7silzjgf6p4f0qk8izvjf0dlppvxjf44f381kkamm6viiqd"; })

     

       104
       104
       +
             (fetchNuGet { pname = "runtime.linux-arm64.Microsoft.NETCore.DotNetAppHost"; version = "8.0.2"; sha256 = "0bvivl9ffgpsq4rbv8n8ivw9jr8yykbsp8r77n23xjm5vz8fcaks"; })

     

       105
       105
       +
             (fetchNuGet { pname = "runtime.linux-arm64.Microsoft.NETCore.DotNetHost"; version = "8.0.2"; sha256 = "1k6vv7mpa81pjx1v8wd8d7ns3wr3ydql1ihx59s6cfg8fx18j5w9"; })

     

       106
       106
       +
             (fetchNuGet { pname = "runtime.linux-arm64.Microsoft.NETCore.DotNetHostPolicy"; version = "8.0.2"; sha256 = "05480dq2mzzfvk9whlz16lq0rs2kzy55d905cl832df6j36yzy9w"; })

     

       107
       107
       +
             (fetchNuGet { pname = "runtime.linux-arm64.Microsoft.NETCore.DotNetHostResolver"; version = "8.0.2"; sha256 = "1gm5yrbyh6h09lsr7izbg7izqiq3nwf7cx4y12hwk63544hprh2j"; })

     

       108
       108
       +
             (fetchNuGet { pname = "runtime.linux-arm.Microsoft.NETCore.DotNetAppHost"; version = "8.0.2"; sha256 = "0wqdx4h3isn1la8wbm8mvip0ai3fspvr8q2g2hx04lylpilcwnfy"; })

     

       109
       109
       +
             (fetchNuGet { pname = "runtime.linux-arm.Microsoft.NETCore.DotNetHost"; version = "8.0.2"; sha256 = "16l4dzmqsjnppl8ra3dz3062na1324zqpibcb9kk6aliayzkwjmp"; })

     

       110
       110
       +
             (fetchNuGet { pname = "runtime.linux-arm.Microsoft.NETCore.DotNetHostPolicy"; version = "8.0.2"; sha256 = "0qzqbpwa79qizj7yzmmk2kr1ibwdg0m104rp2ava2qp8c9mxx1lq"; })

     

       111
       111
       +
             (fetchNuGet { pname = "runtime.linux-arm.Microsoft.NETCore.DotNetHostResolver"; version = "8.0.2"; sha256 = "10k85lqnczpdnzw43ylkma0iv1wxzqv9x4pfr31zwfb5z5p3m7ja"; })

     

       112
       112
       +
             (fetchNuGet { pname = "runtime.linux-musl-arm64.Microsoft.NETCore.DotNetAppHost"; version = "8.0.2"; sha256 = "0yd9vf8z1p264411p4y2aka4dnzhjvi7zhxc9dy6yfjwndlqfz03"; })

     

       113
       113
       +
             (fetchNuGet { pname = "runtime.linux-musl-arm64.Microsoft.NETCore.DotNetHost"; version = "8.0.2"; sha256 = "1vhi86iwln4pv2k0v6xfx5rp2vk5l6l4p399rj63wmm928n3v2la"; })

     

       114
       114
       +
             (fetchNuGet { pname = "runtime.linux-musl-arm64.Microsoft.NETCore.DotNetHostPolicy"; version = "8.0.2"; sha256 = "0i7l7zw99nfq1s43d4cyhs9p5bx719x0q1fmlkp8am4mwga554kf"; })

     

       115
       115
       +
             (fetchNuGet { pname = "runtime.linux-musl-arm64.Microsoft.NETCore.DotNetHostResolver"; version = "8.0.2"; sha256 = "1ny0hjyip2n9mv0iiv2rpikb3apk4cjhvcdi17xn6vf3m79xxbwi"; })

     

       116
       116
       +
             (fetchNuGet { pname = "runtime.linux-musl-x64.Microsoft.NETCore.DotNetAppHost"; version = "8.0.2"; sha256 = "0cllix46qh7lxihkaaxhb3islwn8vqn5lkr4c8c3bynvyblskjvw"; })

     

       117
       117
       +
             (fetchNuGet { pname = "runtime.linux-musl-x64.Microsoft.NETCore.DotNetHost"; version = "8.0.2"; sha256 = "1f20gw4sq0s8idysdbpgrdh5l8ik3lry0i3nq60km9z9n183svxd"; })

     

       118
       118
       +
             (fetchNuGet { pname = "runtime.linux-musl-x64.Microsoft.NETCore.DotNetHostPolicy"; version = "8.0.2"; sha256 = "0c31vfab355bi27wlz18azpyir9y89nn8dcg43j074whc469q0vx"; })

     

       119
       119
       +
             (fetchNuGet { pname = "runtime.linux-musl-x64.Microsoft.NETCore.DotNetHostResolver"; version = "8.0.2"; sha256 = "1xmy68m6vslqbl4njllgqscdslqj7xgkgjzpx4pq344mxh6r9agc"; })

     

       120
       120
       +
             (fetchNuGet { pname = "runtime.linux-x64.Microsoft.NETCore.DotNetAppHost"; version = "8.0.2"; sha256 = "0s93dmisai8wgjid697rgdx3lw2a0s0krr1gcnaav8jz9dg9i8lc"; })

     

       121
       121
       +
             (fetchNuGet { pname = "runtime.linux-x64.Microsoft.NETCore.DotNetHost"; version = "8.0.2"; sha256 = "0ikwfn1q8jkvzyx77b8ycm7k7004j2w8zgjzkf8kgyw55gy8xfjm"; })

     

       122
       122
       +
             (fetchNuGet { pname = "runtime.linux-x64.Microsoft.NETCore.DotNetHostPolicy"; version = "8.0.2"; sha256 = "0gcwjjaw1lajqmwaji0x03w24721dczgnqrzqjw5ayjh8ib3dir2"; })

     

       123
       123
       +
             (fetchNuGet { pname = "runtime.linux-x64.Microsoft.NETCore.DotNetHostResolver"; version = "8.0.2"; sha256 = "1i6wijgpksz81hg01c2pwi06k413x6vni4x8v3y38jyazg7qkfp0"; })

     

       124
       124
       +
             (fetchNuGet { pname = "runtime.osx-x64.Microsoft.NETCore.DotNetAppHost"; version = "8.0.2"; sha256 = "0hsby9ssa974cqkcc29xrjrrqmxyhfkkssmmhrrimh46n7sxzqab"; })

     

       125
       125
       +
             (fetchNuGet { pname = "runtime.osx-x64.Microsoft.NETCore.DotNetHost"; version = "8.0.2"; sha256 = "0vwlfcpvbjhw0qmqnscnin75a5lb5llhzjizcp3nh5mjnkdghd8q"; })

     

       126
       126
       +
             (fetchNuGet { pname = "runtime.osx-x64.Microsoft.NETCore.DotNetHostPolicy"; version = "8.0.2"; sha256 = "00kv6ijg6yway8km36yj7jq9y1p87iw8b8ysga66qv05y4fvjch1"; })

     

       127
       127
       +
             (fetchNuGet { pname = "runtime.osx-x64.Microsoft.NETCore.DotNetHostResolver"; version = "8.0.2"; sha256 = "05dz9mxc94y59y6ja05zamdp63qfdss831816y28kjjw4v4crz1q"; })

     

       128
       128
       +
             (fetchNuGet { pname = "runtime.win-arm64.Microsoft.NETCore.DotNetAppHost"; version = "8.0.2"; sha256 = "0qbm5zgvcwmmqlcj4jaixbw4a1zzyrf8ap81nlqjfdxp03bv9zqa"; })

     

       129
       129
       +
             (fetchNuGet { pname = "runtime.win-arm64.Microsoft.NETCore.DotNetHost"; version = "8.0.2"; sha256 = "1jsnxh1hgy7jrjhbz4kf6gq2x3smfx071cb2w1fa3a740h3i0f4m"; })

     

       130
       130
       +
             (fetchNuGet { pname = "runtime.win-arm64.Microsoft.NETCore.DotNetHostPolicy"; version = "8.0.2"; sha256 = "1738mc91wy3yn2bf4srs2wxksd864hm565nmll396q6gw97a4df4"; })

     

       131
       131
       +
             (fetchNuGet { pname = "runtime.win-arm64.Microsoft.NETCore.DotNetHostResolver"; version = "8.0.2"; sha256 = "152jc4v2zxcax55vmd9xrsxq76q4cqpjlgrd1mfszipnngrlrc71"; })

     

       132
       132
       +
             (fetchNuGet { pname = "runtime.win-x64.Microsoft.NETCore.DotNetAppHost"; version = "8.0.2"; sha256 = "1z9fa5ryi23sn163j7jry45f64rxqkgv7v91r04b9cpb4hc1qgym"; })

     

       133
       133
       +
             (fetchNuGet { pname = "runtime.win-x64.Microsoft.NETCore.DotNetHost"; version = "8.0.2"; sha256 = "14qz0ypylcwldyjn1ins8syjzbqpmfsy4nfkzri12mfn0626qmn2"; })

     

       134
       134
       +
             (fetchNuGet { pname = "runtime.win-x64.Microsoft.NETCore.DotNetHostPolicy"; version = "8.0.2"; sha256 = "136ss58j9wpxp6sj81mijlk32l2f6h81rvaq4l7x0s8wb9fzzbb5"; })

     

       135
       135
       +
             (fetchNuGet { pname = "runtime.win-x64.Microsoft.NETCore.DotNetHostResolver"; version = "8.0.2"; sha256 = "02562zc9nrkfwikzff7km6mixxb1qf632r60jpzykizgx6w0nrck"; })

     

       136
       136
       +
             (fetchNuGet { pname = "runtime.win-x86.Microsoft.NETCore.DotNetAppHost"; version = "8.0.2"; sha256 = "1sylbjvrr1jnlgd1215czr3xql2gdqy5h5sz7rnfq31hb1j5nc20"; })

     

       137
       137
       +
             (fetchNuGet { pname = "runtime.win-x86.Microsoft.NETCore.DotNetHost"; version = "8.0.2"; sha256 = "0ia1igli2r5gnli0r0yzqm012l56zrjf1jk42viahlil2ic3i144"; })

     

       138
       138
       +
             (fetchNuGet { pname = "runtime.win-x86.Microsoft.NETCore.DotNetHostPolicy"; version = "8.0.2"; sha256 = "0h1kydv3dxnd9s32fd68x44jhc2pm79gv44mb7jf4227lr1dcxss"; })

     

       139
       139
       +
             (fetchNuGet { pname = "runtime.win-x86.Microsoft.NETCore.DotNetHostResolver"; version = "8.0.2"; sha256 = "1njywfwlq2785yk4b0114nzdb33zsgsmqj5fhpr6ii1crym649hl"; })

     

       140
       140
       +
             (fetchNuGet { pname = "Microsoft.NETCore.App.Host.linux-musl-arm"; version = "8.0.2"; sha256 = "16lp15z1msadrhiqlwwp0ni9k0slp3am05gqs5bagzwk35mcn27q"; })

     

       141
       141
       +
             (fetchNuGet { pname = "Microsoft.NETCore.App.Host.osx-arm64"; version = "8.0.2"; sha256 = "1v8nngksh0cp51g221bizz52jjpc4rzm1avcy5psl81ywmkwmj93"; })

     

       142
       142
       +
             (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.linux-musl-arm"; version = "8.0.2"; sha256 = "142s1ricyk351nqg298w5qlzd4scz8pc66x5mw9qh75vcyxsr83f"; })

     

       143
       143
       +
             (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.osx-arm64"; version = "8.0.2"; sha256 = "116rkq5ri5dbhp5g7zyc71ml2v92vb5bw5f3nx96llb1pqk74grh"; })

     

       144
       144
       +
             (fetchNuGet { pname = "Microsoft.NETCore.App.Ref"; version = "8.0.2"; sha256 = "1c2n7cfc7b6sjgk84hxppv57sh1n4dy49cmdd16ki1l6yl2f3j9d"; })

     

       145
       145
       +
             (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.Mono.linux-arm"; version = "8.0.2"; sha256 = "0c6v2mdfshy5966fl2pfkfhgfs8y1sd0r47lfx7d4igy933dqfga"; })

     

       146
       146
       +
             (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.Mono.linux-arm64"; version = "8.0.2"; sha256 = "1g8asdz9f3i0mjyh1mkxzfc6x8x77z0d88fa6irpyhh0w45qfccw"; })

     

       147
       147
       +
             (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.Mono.linux-musl-x64"; version = "8.0.2"; sha256 = "14djb55i8nwsr3170b82lr89dqxjghnkkghxxy2sl4d2bxw0bsfa"; })

     

       148
       148
       +
             (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.Mono.linux-x64"; version = "8.0.2"; sha256 = "0h0cc31c1izakpx554kivjqw3s5030a9zy3q4a2apwyj16znv2cw"; })

     

       149
       149
       +
             (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.Mono.osx-arm64"; version = "8.0.2"; sha256 = "18599d4y8n4y0w489pg7zm4nd4a23iz4zwx317pr5z57b4wrk61k"; })

     

       150
       150
       +
             (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.Mono.osx-x64"; version = "8.0.2"; sha256 = "04wvf035rr5kw6bj46ici8353lx5k95slydpm42kv1fcy3slqb4p"; })

     

       151
       151
       +
             (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.Mono.win-x64"; version = "8.0.2"; sha256 = "1adxkh9y3y9cxisrn52c75dmzgfkbnz9aqs2p97ln9qdxxvhzhc2"; })

     

       152
       152
       +
             (fetchNuGet { pname = "Microsoft.NETCore.App.Runtime.Mono.win-x86"; version = "8.0.2"; sha256 = "0721kp5l7k25ivi2sdxx12kjpddas5l6y5qjmfw8pjcyximhqn0b"; })

     

       153
       153
       +
             (fetchNuGet { pname = "runtime.linux-musl-arm.Microsoft.NETCore.DotNetAppHost"; version = "8.0.2"; sha256 = "1kkjmyhrnghihhfvm3qjrkrjbml2nqv8vyslj0g79pjanaqv3prs"; })

     

       154
       154
       +
             (fetchNuGet { pname = "runtime.linux-musl-arm.Microsoft.NETCore.DotNetHost"; version = "8.0.2"; sha256 = "1j5qhbgy9d1d89xcgdyjcnww0ziad846nd6x5l8fa109z8wvsnki"; })

     

       155
       155
       +
             (fetchNuGet { pname = "runtime.linux-musl-arm.Microsoft.NETCore.DotNetHostPolicy"; version = "8.0.2"; sha256 = "12n0m0rbxp05ggrkxa9yr6kn46pnn3pc4c22p6kkv5ijyg8nhd74"; })

     

       156
       156
       +
             (fetchNuGet { pname = "runtime.linux-musl-arm.Microsoft.NETCore.DotNetHostResolver"; version = "8.0.2"; sha256 = "1mhwggjfpwssyzxl2mj3j9017xc8qwnw4xlm2rn96yfgsd1pxfpv"; })

     

       157
       157
       +
             (fetchNuGet { pname = "runtime.osx-arm64.Microsoft.NETCore.DotNetAppHost"; version = "8.0.2"; sha256 = "1nvis5p0gvymv6sdrmgpgg94sr2w3maskm0c3d8p861wfiwwh0hv"; })

     

       158
       158
       +
             (fetchNuGet { pname = "runtime.osx-arm64.Microsoft.NETCore.DotNetHost"; version = "8.0.2"; sha256 = "1vjrnga6inham84hggkx1kkpx4yn7v7z1xnwxas9lisxd0ych7k1"; })

     

       159
       159
       +
             (fetchNuGet { pname = "runtime.osx-arm64.Microsoft.NETCore.DotNetHostPolicy"; version = "8.0.2"; sha256 = "0rrblgydpz3yf5gj9kpjc8b17x739nzr1956pwwyarhvh9y0vqrd"; })

     

       160
       160
       +
             (fetchNuGet { pname = "runtime.osx-arm64.Microsoft.NETCore.DotNetHostResolver"; version = "8.0.2"; sha256 = "0xpsaxi54g0xac80gy5nv7qk5b513ak1s397b36vwg7mivwc4yhh"; })

     

       161
       161
       +
             (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.linux-musl-arm"; version = "8.0.2"; sha256 = "1nm6ibys303xlawqibqygpg1gqc8wm1nxb6pl6vgwmp5w4q02r5h"; })

     

       162
       162
       +
             (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.linux-musl-arm64"; version = "8.0.2"; sha256 = "0h6wwlz3mqb8758laczcaq7a0wmnmjf797dh5xwyiq50j1ss1mhw"; })

     

       163
       163
       +
             (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.linux-musl-x64"; version = "8.0.2"; sha256 = "09id8hnx0s4x5qvmvifb6jhkfaxzj53yvhl84pvrr4wv4p6ns7cm"; })

     

       164
       164
       +
             (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.linux-arm"; version = "8.0.2"; sha256 = "0cg7b57fysgw809m77nb9dqr56g48ya6bjlh7x880ih5b76bnlak"; })

     

       165
       165
       +
             (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.linux-arm64"; version = "8.0.2"; sha256 = "1rqr95ix3khc7mbaji520l2vv8vjbrg8zzpv6h1i3p3rdbzjm3l2"; })

     

       166
       166
       +
             (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.linux-x64"; version = "8.0.2"; sha256 = "0kzvyghyj95p2qxidp1g8nx5d9qd7wlchpg1a5dqbpv9skljdn7m"; })

     

       167
       167
       +
             (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.osx-x64"; version = "8.0.2"; sha256 = "0hmk25bvlpn3sfx4vlvysj2myx4dd8fc2pv3gmhfgb2y01dnswjh"; })

     

       168
       168
       +
             (fetchNuGet { pname = "Microsoft.NETCore.App.Crossgen2.osx-arm64"; version = "8.0.2"; sha256 = "1z76l5mpvik3517lcl3qygsfsws4yp37j37sslb4sq7gls4aa0w2"; })

     

       169
       169
       +
             (fetchNuGet { pname = "runtime.linux-arm64.Microsoft.DotNet.ILCompiler"; version = "8.0.2"; sha256 = "1kjlc67bqz7d04ga42l7jm9d3jm773a9i77zc5w7cd591wa8vbbv"; })

     

       170
       170
       +
             (fetchNuGet { pname = "runtime.linux-musl-arm64.Microsoft.DotNet.ILCompiler"; version = "8.0.2"; sha256 = "0bx7jv4q8dapx6fb6dbk1im057qmk43isvzygp5ci6nd07p419qf"; })

     

       171
       171
       +
             (fetchNuGet { pname = "runtime.linux-musl-x64.Microsoft.DotNet.ILCompiler"; version = "8.0.2"; sha256 = "1nf6m85f10j5qcyk0w18qxd06n79w0jvnifis08shdsq1isz403z"; })

     

       172
       172
       +
             (fetchNuGet { pname = "runtime.linux-x64.Microsoft.DotNet.ILCompiler"; version = "8.0.2"; sha256 = "0pl0w114qrlb8bv6d4jw1gv29dz2cs86y3r0nj5z2fxd1r30khym"; })

     

       173
       173
       +
             (fetchNuGet { pname = "runtime.osx-x64.Microsoft.DotNet.ILCompiler"; version = "8.0.2"; sha256 = "05bs32vhcvpd1dbvmk1rgqm2swp4gn5yv4mwfsisa4q5qi2xlaza"; })

     

       174
       174
       +
             (fetchNuGet { pname = "runtime.win-arm64.Microsoft.DotNet.ILCompiler"; version = "8.0.2"; sha256 = "12q0adp0hakl9qrf4bqzkvfsy4az55im6sm1nv7g3k5q4vwkqh30"; })

     

       175
       175
       +
             (fetchNuGet { pname = "runtime.win-x64.Microsoft.DotNet.ILCompiler"; version = "8.0.2"; sha256 = "1k1iwpsranma2mrljfz9yr63pxbv5l9j4n0zmancbsxlhx31m30s"; })

     

       176
       176
       +
             (fetchNuGet { pname = "Microsoft.NET.ILLink.Tasks"; version = "8.0.2"; sha256 = "1fd7ws4qf0354np3lvd735p5r1mdj3zy6gbmv5fzz5cx2bdlplwy"; })

     

       177
       177
       +
           ];

     

       178
       178
       +
         };

     

       179
       179
       +
       }

+332

pkgs/development/compilers/dotnet/vmr.nix

···

       1
       1
       +
       { clangStdenv

     

       2
       2
       +
       , stdenvNoCC

     

       3
       3
       +
       , lib

     

       4
       4
       +
       , fetchurl

     

       5
       5
       +
       , fetchFromGitHub

     

       6
       6
       +
       , dotnetCorePackages

     

       7
       7
       +
       , jq

     

       8
       8
       +
       , curl

     

       9
       9
       +
       , git

     

       10
       10
       +
       , cmake

     

       11
       11
       +
       , pkg-config

     

       12
       12
       +
       , llvm

     

       13
       13
       +
       , zlib

     

       14
       14
       +
       , icu

     

       15
       15
       +
       , lttng-ust_2_12

     

       16
       16
       +
       , libkrb5

     

       17
       17
       +
       , glibcLocales

     

       18
       18
       +
       , ensureNewerSourcesForZipFilesHook

     

       19
       19
       +
       , darwin

     

       20
       20
       +
       , xcbuild

     

       21
       21
       +
       , swiftPackages

     

       22
       22
       +
       , openssl

     

       23
       23
       +
       , getconf

     

       24
       24
       +
       , makeWrapper

     

       25
       25
       +
       , python3

     

       26
       26
       +
       , xmlstarlet

     

       27
       27
       +
       , callPackage

     

       28
       28
       +
       

     

       29
       29
       +
       , dotnetSdk

     

       30
       30
       +
       , releaseManifestFile

     

       31
       31
       +
       , tarballHash

     

       32
       32
       +
       }:

     

       33
       33
       +
       

     

       34
       34
       +
       let

     

       35
       35
       +
         stdenv = if clangStdenv.isDarwin

     

       36
       36
       +
           then swiftPackages.stdenv

     

       37
       37
       +
           else clangStdenv;

     

       38
       38
       +
       

     

       39
       39
       +
         inherit (stdenv)

     

       40
       40
       +
           isLinux

     

       41
       41
       +
           isDarwin

     

       42
       42
       +
           buildPlatform

     

       43
       43
       +
           targetPlatform;

     

       44
       44
       +
         inherit (darwin) cctools;

     

       45
       45
       +
         inherit (swiftPackages) apple_sdk swift;

     

       46
       46
       +
       

     

       47
       47
       +
         releaseManifest = lib.importJSON releaseManifestFile;

     

       48
       48
       +
         inherit (releaseManifest) release sourceRepository tag;

     

       49
       49
       +
       

     

       50
       50
       +
         buildRid = dotnetCorePackages.systemToDotnetRid buildPlatform.system;

     

       51
       51
       +
         targetRid = dotnetCorePackages.systemToDotnetRid targetPlatform.system;

     

       52
       52
       +
         targetArch = lib.elemAt (lib.splitString "-" targetRid) 1;

     

       53
       53
       +
       

     

       54
       54
       +
         sigtool = callPackage ./sigtool.nix {};

     

       55
       55
       +
       

     

       56
       56
       +
         # we need dwarfdump from cctools, but can't have e.g. 'ar' overriding stdenv

     

       57
       57
       +
         dwarfdump = stdenvNoCC.mkDerivation {

     

       58
       58
       +
           name = "dwarfdump-wrapper";

     

       59
       59
       +
           dontUnpack = true;

     

       60
       60
       +
           installPhase = ''

     

       61
       61
       +
             mkdir -p "$out/bin"

     

       62
       62
       +
             ln -s "${cctools}/bin/dwarfdump" "$out/bin"

     

       63
       63
       +
           '';

     

       64
       64
       +
         };

     

       65
       65
       +
       

     

       66
       66
       +
         _icu = if isDarwin then darwin.ICU else icu;

     

       67
       67
       +
       

     

       68
       68
       +
       in stdenv.mkDerivation rec {

     

       69
       69
       +
         pname = "dotnet-vmr";

     

       70
       70
       +
         version = release;

     

       71
       71
       +
       

     

       72
       72
       +
         # TODO: fix this in the binary sdk packages

     

       73
       73
       +
         preHook = lib.optionalString stdenv.isDarwin ''

     

       74
       74
       +
           addToSearchPath DYLD_LIBRARY_PATH "${_icu}/lib"

     

       75
       75
       +
           export DYLD_LIBRARY_PATH

     

       76
       76
       +
         '';

     

       77
       77
       +
       

     

       78
       78
       +
         src = fetchurl {

     

       79
       79
       +
           url = "${sourceRepository}/archive/refs/tags/${tag}.tar.gz";

     

       80
       80
       +
           hash = tarballHash;

     

       81
       81
       +
         };

     

       82
       82
       +
       

     

       83
       83
       +
         nativeBuildInputs = [

     

       84
       84
       +
           ensureNewerSourcesForZipFilesHook

     

       85
       85
       +
           jq

     

       86
       86
       +
           curl.bin

     

       87
       87
       +
           git

     

       88
       88
       +
           cmake

     

       89
       89
       +
           pkg-config

     

       90
       90
       +
           python3

     

       91
       91
       +
           xmlstarlet

     

       92
       92
       +
         ]

     

       93
       93
       +
         ++ lib.optionals isDarwin [

     

       94
       94
       +
           getconf

     

       95
       95
       +
         ];

     

       96
       96
       +
       

     

       97
       97
       +
         buildInputs = [

     

       98
       98
       +
           # this gets copied into the tree, but we still want the hooks to run

     

       99
       99
       +
           dotnetSdk

     

       100
       100
       +
           # the propagated build inputs in llvm.dev break swift compilation

     

       101
       101
       +
           llvm.out

     

       102
       102
       +
           zlib

     

       103
       103
       +
           _icu

     

       104
       104
       +
           openssl

     

       105
       105
       +
         ]

     

       106
       106
       +
         ++ lib.optionals isLinux [

     

       107
       107
       +
           libkrb5

     

       108
       108
       +
           lttng-ust_2_12

     

       109
       109
       +
         ]

     

       110
       110
       +
         ++ lib.optionals isDarwin (with apple_sdk.frameworks; [

     

       111
       111
       +
           xcbuild.xcrun

     

       112
       112
       +
           swift

     

       113
       113
       +
           (libkrb5.overrideAttrs (old: {

     

       114
       114
       +
             # the propagated build inputs break swift compilation

     

       115
       115
       +
             buildInputs = old.buildInputs ++ old.propagatedBuildInputs;

     

       116
       116
       +
             propagatedBuildInputs = [];

     

       117
       117
       +
           }))

     

       118
       118
       +
           dwarfdump

     

       119
       119
       +
           sigtool

     

       120
       120
       +
           Foundation

     

       121
       121
       +
           CoreFoundation

     

       122
       122
       +
           CryptoKit

     

       123
       123
       +
           System

     

       124
       124
       +
         ]);

     

       125
       125
       +
       

     

       126
       126
       +
         # This is required to fix the error:

     

       127
       127
       +
         # > CSSM_ModuleLoad(): One or more parameters passed to a function were not valid.

     

       128
       128
       +
         # The error occurs during

     

       129
       129
       +
         # AppleCryptoNative_X509ImportCollection -> ReadX509 -> SecItemImport

     

       130
       130
       +
         # while importing trustedroots/codesignctl.pem. This happens during any dotnet

     

       131
       131
       +
         # restore operation.

     

       132
       132
       +
         # Enabling com.apple.system.opendirectoryd.membership causes swiftc to use

     

       133
       133
       +
         # /var/folders for its default cache path, so the swiftc -module-cache-path

     

       134
       134
       +
         # patch below is required.

     

       135
       135
       +
         sandboxProfile = ''

     

       136
       136
       +
           (allow file-read* (subpath "/private/var/db/mds/system"))

     

       137
       137
       +
           (allow mach-lookup (global-name "com.apple.SecurityServer")

     

       138
       138
       +
                              (global-name "com.apple.system.opendirectoryd.membership"))

     

       139
       139
       +
         '';

     

       140
       140
       +
       

     

       141
       141
       +
         patches = [

     

       142
       142
       +
           ./fix-aspnetcore-portable-build.patch

     

       143
       143
       +
           ./fix-tmp-path.patch

     

       144
       144
       +
         ]

     

       145
       145
       +
         ++ lib.optionals isDarwin [

     

       146
       146
       +
           ./stop-passing-bare-sdk-arg-to-swiftc.patch

     

       147
       147
       +
         ];

     

       148
       148
       +
       

     

       149
       149
       +
         postPatch = ''

     

       150
       150
       +
           # set the sdk version in global.json to match the bootstrap sdk

     

       151
       151
       +
           jq '(.tools.dotnet=$dotnet)' global.json --arg dotnet "$(${dotnetSdk}/bin/dotnet --version)" > global.json~

     

       152
       152
       +
           mv global.json{~,}

     

       153
       153
       +
       

     

       154
       154
       +
           patchShebangs $(find -name \*.sh -type f -executable)

     

       155
       155
       +
       

     

       156
       156
       +
           # I'm not sure why this is required, but these files seem to use the wrong

     

       157
       157
       +
           # property name.

     

       158
       158
       +
           # TODO: not needed in 9.0?

     

       159
       159
       +
           [[ ! -f src/xliff-tasks/eng/Versions.props ]] || \

     

       160
       160
       +
             sed -i 's:\bVersionBase\b:VersionPrefix:g' \

     

       161
       161
       +
               src/xliff-tasks/eng/Versions.props

     

       162
       162
       +
       

     

       163
       163
       +
           # at least in 9.0 preview 1, this package depends on a specific beta build

     

       164
       164
       +
           # of System.CommandLine

     

       165
       165
       +
           xmlstarlet ed \

     

       166
       166
       +
             --inplace \

     

       167
       167
       +
             -s //Project -t elem -n PropertyGroup \

     

       168
       168
       +
             -s \$prev -t elem -n NoWarn -v '$(NoWarn);NU1603' \

     

       169
       169
       +
             src/nuget-client/src/NuGet.Core/NuGet.CommandLine.XPlat/NuGet.CommandLine.XPlat.csproj

     

       170
       170
       +
       

     

       171
       171
       +
           # AD0001 crashes intermittently in source-build-reference-packages with

     

       172
       172
       +
           # CSC : error AD0001: Analyzer 'Microsoft.NetCore.CSharp.Analyzers.Runtime.CSharpDetectPreviewFeatureAnalyzer' threw an exception of type 'System.NullReferenceException' with message 'Object reference not set to an instance of an object.'.

     

       173
       173
       +
           # possibly related to https://github.com/dotnet/runtime/issues/90356

     

       174
       174
       +
           xmlstarlet ed \

     

       175
       175
       +
             --inplace \

     

       176
       176
       +
             -s //Project -t elem -n PropertyGroup \

     

       177
       177
       +
             -s \$prev -t elem -n NoWarn -v '$(NoWarn);AD0001' \

     

       178
       178
       +
             src/source-build-reference-packages/src/referencePackages/Directory.Build.props

     

       179
       179
       +
       

     

       180
       180
       +
           # https://github.com/microsoft/ApplicationInsights-dotnet/issues/2848

     

       181
       181
       +
           xmlstarlet ed \

     

       182
       182
       +
             --inplace \

     

       183
       183
       +
             -u //_:Project/_:PropertyGroup/_:BuildNumber -v 0 \

     

       184
       184
       +
             src/source-build-externals/src/application-insights/.props/_GlobalStaticVersion.props

     

       185
       185
       +
       

     

       186
       186
       +
           # this fixes compile errors with clang 15 (e.g. darwin)

     

       187
       187
       +
           substituteInPlace \

     

       188
       188
       +
             src/runtime/src/native/libs/CMakeLists.txt \

     

       189
       189
       +
             --replace-fail 'add_compile_options(-Weverything)' 'add_compile_options(-Wall)'

     

       190
       190
       +
         ''

     

       191
       191
       +
         + lib.optionalString isLinux ''

     

       192
       192
       +
           substituteInPlace \

     

       193
       193
       +
             src/runtime/src/native/libs/System.Security.Cryptography.Native/opensslshim.c \

     

       194
       194
       +
             --replace-fail '"libssl.so"' '"${openssl.out}/lib/libssl.so"'

     

       195
       195
       +
       

     

       196
       196
       +
           substituteInPlace \

     

       197
       197
       +
             src/runtime/src/native/libs/System.Net.Security.Native/pal_gssapi.c \

     

       198
       198
       +
             --replace-fail '"libgssapi_krb5.so.2"' '"${libkrb5}/lib/libgssapi_krb5.so.2"'

     

       199
       199
       +
       

     

       200
       200
       +
           substituteInPlace \

     

       201
       201
       +
             src/runtime/src/native/libs/System.Globalization.Native/pal_icushim.c \

     

       202
       202
       +
             --replace-fail '"libicui18n.so"' '"${icu}/lib/libicui18n.so"' \

     

       203
       203
       +
             --replace-fail '"libicuuc.so"' '"${icu}/lib/libicuuc.so"'

     

       204
       204
       +
       

     

       205
       205
       +
           # TODO: we should really make sure the first one (9.0) or the rest (8.0)

     

       206
       206
       +
           # works, but --replace-fail results in an empty file

     

       207
       207
       +
           substituteInPlace \

     

       208
       208
       +
             src/runtime/src/native/libs/System.Globalization.Native/pal_icushim.c \

     

       209
       209
       +
             --replace-warn '#define VERSIONED_LIB_NAME_LEN 64' '#define VERSIONED_LIB_NAME_LEN 256' \

     

       210
       210
       +
             --replace-warn 'libicuucName[64]' 'libicuucName[256]' \

     

       211
       211
       +
             --replace-warn 'libicui18nName[64]' 'libicui18nName[256]'

     

       212
       212
       +
         ''

     

       213
       213
       +
         + lib.optionalString isDarwin ''

     

       214
       214
       +
           substituteInPlace \

     

       215
       215
       +
             src/runtime/src/mono/CMakeLists.txt \

     

       216
       216
       +
             src/runtime/src/native/libs/System.Globalization.Native/CMakeLists.txt \

     

       217
       217
       +
             --replace-fail '/usr/lib/libicucore.dylib' '${darwin.ICU}/lib/libicucore.dylib'

     

       218
       218
       +
       

     

       219
       219
       +
           substituteInPlace \

     

       220
       220
       +
             src/runtime/src/installer/managed/Microsoft.NET.HostModel/HostModelUtils.cs \

     

       221
       221
       +
             src/sdk/src/Tasks/Microsoft.NET.Build.Tasks/targets/Microsoft.NET.Sdk.targets \

     

       222
       222
       +
             --replace-fail '/usr/bin/codesign' '${sigtool}/bin/codesign'

     

       223
       223
       +
       

     

       224
       224
       +
           # [...]/build.proj(123,5): error : Did not find PDBs for the following SDK files:

     

       225
       225
       +
           # [...]/build.proj(123,5): error : sdk/8.0.102/System.Resources.Extensions.dll

     

       226
       226
       +
           # [...]/build.proj(123,5): error : sdk/8.0.102/System.CodeDom.dll

     

       227
       227
       +
           # [...]/build.proj(123,5): error : sdk/8.0.102/FSharp/System.Resources.Extensions.dll

     

       228
       228
       +
           # [...]/build.proj(123,5): error : sdk/8.0.102/FSharp/System.CodeDom.dll

     

       229
       229
       +
           substituteInPlace \

     

       230
       230
       +
             build.proj \

     

       231
       231
       +
             --replace-warn 'FailOnMissingPDBs="true"' 'FailOnMissingPDBs="false"'

     

       232
       232
       +
       

     

       233
       233
       +
           # [...]/installer.singlerid.targets(434,5): error MSB3073: The command "pkgbuild [...]" exited with code 127

     

       234
       234
       +
           xmlstarlet ed \

     

       235
       235
       +
             --inplace \

     

       236
       236
       +
             -s //Project -t elem -n PropertyGroup \

     

       237
       237
       +
             -s \$prev -t elem -n InnerBuildArgs -v '$(InnerBuildArgs) /p:SkipInstallerBuild=true' \

     

       238
       238
       +
             src/runtime/eng/SourceBuild.props

     

       239
       239
       +
       

     

       240
       240
       +
           # fixes swift errors, see sandboxProfile

     

       241
       241
       +
           # <unknown>:0: error: unable to open output file '/var/folders/[...]/C/clang/ModuleCache/[...]/SwiftShims-[...].pcm': 'Operation not permitted'

     

       242
       242
       +
           # <unknown>:0: error: could not build Objective-C module 'SwiftShims'

     

       243
       243
       +
           substituteInPlace \

     

       244
       244
       +
             src/runtime/src/native/libs/System.Security.Cryptography.Native.Apple/CMakeLists.txt \

     

       245
       245
       +
             --replace-fail 'xcrun swiftc' 'xcrun swiftc -module-cache-path "$ENV{HOME}/.cache/module-cache"'

     

       246
       246
       +
         '';

     

       247
       247
       +
       

     

       248
       248
       +
         prepFlags = [

     

       249
       249
       +
           "--no-artifacts"

     

       250
       250
       +
           "--no-prebuilts"

     

       251
       251
       +
         ];

     

       252
       252
       +
       

     

       253
       253
       +
         configurePhase = ''

     

       254
       254
       +
           runHook preConfigure

     

       255
       255
       +
       

     

       256
       256
       +
           # The build process tries to overwrite some things in the sdk (e.g.

     

       257
       257
       +
           # SourceBuild.MSBuildSdkResolver.dll), so it needs to be mutable.

     

       258
       258
       +
           cp -Tr ${dotnetSdk} .dotnet

     

       259
       259
       +
           chmod -R +w .dotnet

     

       260
       260
       +
       

     

       261
       261
       +
           ./prep.sh $prepFlags

     

       262
       262
       +
       

     

       263
       263
       +
           runHook postConfigure

     

       264
       264
       +
         '';

     

       265
       265
       +
       

     

       266
       266
       +
         dontUseCmakeConfigure = true;

     

       267
       267
       +
       

     

       268
       268
       +
         # https://github.com/NixOS/nixpkgs/issues/38991

     

       269
       269
       +
         # bash: warning: setlocale: LC_ALL: cannot change locale (en_US.UTF-8)

     

       270
       270
       +
         LOCALE_ARCHIVE = lib.optionalString isLinux

     

       271
       271
       +
           "${glibcLocales}/lib/locale/locale-archive";

     

       272
       272
       +
       

     

       273
       273
       +
         buildFlags = [

     

       274
       274
       +
           "--with-packages" dotnetSdk.artifacts

     

       275
       275
       +
           "--clean-while-building"

     

       276
       276
       +
           "--release-manifest" releaseManifestFile

     

       277
       277
       +
           "--"

     

       278
       278
       +
           "-p:PortableBuild=true"

     

       279
       279
       +
         ] ++ lib.optional (targetRid != buildRid) "-p:TargetRid=${targetRid}";

     

       280
       280
       +
       

     

       281
       281
       +
         buildPhase = ''

     

       282
       282
       +
           runHook preBuild

     

       283
       283
       +
       

     

       284
       284
       +
           # on darwin, in a sandbox, this causes:

     

       285
       285
       +
           # CSSM_ModuleLoad(): One or more parameters passed to a function were not valid.

     

       286
       286
       +
           export DOTNET_GENERATE_ASPNET_CERTIFICATE=0

     

       287
       287
       +
       

     

       288
       288
       +
           # CLR_CC/CXX need to be set to stop the build system from using clang-11,

     

       289
       289
       +
           # which is unwrapped

     

       290
       290
       +
           version= \

     

       291
       291
       +
           CLR_CC=$(command -v clang) \

     

       292
       292
       +
           CLR_CXX=$(command -v clang++) \

     

       293
       293
       +
             ./build.sh $buildFlags

     

       294
       294
       +
       

     

       295
       295
       +
           runHook postBuild

     

       296
       296
       +
         '';

     

       297
       297
       +
       

     

       298
       298
       +
         installPhase = ''

     

       299
       299
       +
           runHook preInstall

     

       300
       300
       +
       

     

       301
       301
       +
           mkdir "$out"

     

       302
       302
       +
       

     

       303
       303
       +
           pushd "artifacts/${targetArch}/Release"

     

       304
       304
       +
           for archive in *.tar.gz; do

     

       305
       305
       +
             target=$out/''${archive%.tar.gz}

     

       306
       306
       +
             mkdir "$target"

     

       307
       307
       +
             tar -C "$target" -xzf "$PWD/$archive"

     

       308
       308
       +
           done

     

       309
       309
       +
           popd

     

       310
       310
       +
       

     

       311
       311
       +
           runHook postInstall

     

       312
       312
       +
         '';

     

       313
       313
       +
       

     

       314
       314
       +
         passthru = {

     

       315
       315
       +
           inherit releaseManifest buildRid targetRid;

     

       316
       316
       +
           icu = _icu;

     

       317
       317
       +
         };

     

       318
       318
       +
       

     

       319
       319
       +
         meta = with lib; {

     

       320
       320
       +
           description = "Core functionality needed to create .NET Core projects, that is shared between Visual Studio and CLI";

     

       321
       321
       +
           homepage = "https://dotnet.github.io/";

     

       322
       322
       +
           license = licenses.mit;

     

       323
       323
       +
           maintainers = with maintainers; [ corngood ];

     

       324
       324
       +
           mainProgram = "dotnet";

     

       325
       325
       +
           platforms = [

     

       326
       326
       +
             "x86_64-linux"

     

       327
       327
       +
             "aarch64-linux"

     

       328
       328
       +
             "x86_64-darwin"

     

       329
       329
       +
             "aarch64-darwin"

     

       330
       330
       +
           ];

     

       331
       331
       +
         };

     

       332
       332
       +
       }