diff options
Diffstat (limited to 'pkgs/build-support/dotnet')
8 files changed, 330 insertions, 195 deletions
diff --git a/pkgs/build-support/dotnet/build-dotnet-global-tool/default.nix b/pkgs/build-support/dotnet/build-dotnet-global-tool/default.nix index 16cf029ca3451..7ae9cfc9f6618 100644 --- a/pkgs/build-support/dotnet/build-dotnet-global-tool/default.nix +++ b/pkgs/build-support/dotnet/build-dotnet-global-tool/default.nix @@ -28,7 +28,7 @@ buildDotnetModule (args // { ] ++ (nugetDeps fetchNuGet); }; - projectFile = ""; + dotnetGlobalTool = true; useDotnetFromEnv = true; diff --git a/pkgs/build-support/dotnet/build-dotnet-module/default.nix b/pkgs/build-support/dotnet/build-dotnet-module/default.nix index 15a753df07728..7b88b16064bca 100644 --- a/pkgs/build-support/dotnet/build-dotnet-module/default.nix +++ b/pkgs/build-support/dotnet/build-dotnet-module/default.nix @@ -69,7 +69,7 @@ , disabledTests ? [ ] # The project file to run unit tests against. This is usually referenced in the regular project file, but sometimes it needs to be manually set. # It gets restored and build, but not installed. You may need to regenerate your nuget lockfile after setting this. -, testProjectFile ? "" +, testProjectFile ? null # The type of build to perform. This is passed to `dotnet` with the `--configuration` flag. Possible values are `Release`, `Debug`, etc. , buildType ? "Release" @@ -84,23 +84,22 @@ , dotnet-sdk ? dotnetCorePackages.sdk_6_0 # The dotnet runtime to use. , dotnet-runtime ? dotnetCorePackages.runtime_6_0 - # The dotnet SDK to run tests against. This can differentiate from the SDK compiled against. -, dotnet-test-sdk ? dotnet-sdk , ... } @ args: let + projectFiles = + lib.optionals (projectFile != null) (lib.toList projectFile); + testProjectFiles = + lib.optionals (testProjectFile != null) (lib.toList testProjectFile); + platforms = if args ? meta.platforms then lib.intersectLists args.meta.platforms dotnet-sdk.meta.platforms else dotnet-sdk.meta.platforms; inherit (callPackage ./hooks { - inherit dotnet-sdk dotnet-test-sdk disabledTests nuget-source dotnet-runtime runtimeDeps buildType; - runtimeId = - if runtimeId != null - then runtimeId - else dotnetCorePackages.systemToDotnetRid stdenvNoCC.targetPlatform.system; + inherit dotnet-sdk dotnet-runtime; }) dotnetConfigureHook dotnetBuildHook dotnetCheckHook dotnetInstallHook dotnetFixupHook; localDeps = @@ -121,7 +120,7 @@ let # contains the actual package dependencies dependenciesSource = mkNugetSource { name = "${name}-dependencies-source"; - description = "A Nuget source with the dependencies for ${name}"; + description = "Nuget source with the dependencies for ${name}"; deps = [ _nugetDeps ] ++ lib.optional (localDeps != null) localDeps; }; @@ -145,6 +144,19 @@ let nugetDepsFile = _nugetDeps.sourceFile; in stdenvNoCC.mkDerivation (args // { + dotnetInstallPath = installPath; + dotnetExecutables = executables; + dotnetBuildType = buildType; + dotnetProjectFiles = projectFiles; + dotnetTestProjectFiles = testProjectFiles; + dotnetDisabledTests = disabledTests; + dotnetRuntimeId = runtimeId; + nugetSource = nuget-source; + dotnetRuntimeDeps = map lib.getLib runtimeDeps; + dotnetSelfContainedBuild = selfContainedBuild; + dotnetUseAppHost = useAppHost; + inherit useDotnetFromEnv; + nativeBuildInputs = args.nativeBuildInputs or [ ] ++ [ dotnetConfigureHook dotnetBuildHook @@ -174,7 +186,7 @@ stdenvNoCC.mkDerivation (args // { else [ ])); makeWrapperArgs = args.makeWrapperArgs or [ ] ++ [ - "--prefix LD_LIBRARY_PATH : ${dotnet-sdk.icu}/lib" + "--prefix" "LD_LIBRARY_PATH" ":" "${dotnet-sdk.icu}/lib" ]; # Stripping breaks the executable @@ -183,7 +195,9 @@ stdenvNoCC.mkDerivation (args // { # gappsWrapperArgs gets included when wrapping for dotnet, as to avoid double wrapping dontWrapGApps = args.dontWrapGApps or true; - inherit selfContainedBuild useAppHost useDotnetFromEnv; + # propagate the runtime sandbox profile since the contents apply to published + # executables + propagatedSandboxProfile = toString dotnet-runtime.__propagatedSandboxProfile; passthru = { inherit nuget-source; @@ -265,11 +279,11 @@ stdenvNoCC.mkDerivation (args // { --no-cache \ --force \ ${lib.optionalString (!enableParallelBuilding) "--disable-parallel"} \ - ${lib.optionalString (flags != []) (toString flags)} + ${lib.escapeShellArgs flags} } - declare -a projectFiles=( ${toString (lib.toList projectFile)} ) - declare -a testProjectFiles=( ${toString (lib.toList testProjectFile)} ) + declare -a projectFiles=( ${lib.escapeShellArgs projectFiles} ) + declare -a testProjectFiles=( ${lib.escapeShellArgs testProjectFiles} ) export DOTNET_NOLOGO=1 export DOTNET_CLI_TELEMETRY_OPTOUT=1 @@ -316,8 +330,4 @@ stdenvNoCC.mkDerivation (args // { } // args.passthru or { }; meta = (args.meta or { }) // { inherit platforms; }; -} - # ICU tries to unconditionally load files from /usr/share/icu on Darwin, which makes builds fail - # in the sandbox, so disable ICU on Darwin. This, as far as I know, shouldn't cause any built packages - # to behave differently, just the dotnet build tool. - // lib.optionalAttrs stdenvNoCC.isDarwin { DOTNET_SYSTEM_GLOBALIZATION_INVARIANT = 1; }) +}) diff --git a/pkgs/build-support/dotnet/build-dotnet-module/hooks/default.nix b/pkgs/build-support/dotnet/build-dotnet-module/hooks/default.nix index 7012ff36a4a55..b9c51a743c6a6 100644 --- a/pkgs/build-support/dotnet/build-dotnet-module/hooks/default.nix +++ b/pkgs/build-support/dotnet/build-dotnet-module/hooks/default.nix @@ -4,30 +4,21 @@ , coreutils , zlib , openssl -, callPackage , makeSetupHook -, makeWrapper +, dotnetCorePackages + # Passed from ../default.nix , dotnet-sdk -, dotnet-test-sdk -, disabledTests -, nuget-source , dotnet-runtime -, runtimeDeps -, buildType -, runtimeId }: -assert (builtins.isString runtimeId); - let - libraryPath = lib.makeLibraryPath runtimeDeps; + runtimeId = dotnetCorePackages.systemToDotnetRid stdenv.hostPlatform.system; in { - dotnetConfigureHook = callPackage ({ }: - makeSetupHook { + dotnetConfigureHook = makeSetupHook + { name = "dotnet-configure-hook"; - propagatedBuildInputs = [ dotnet-sdk nuget-source ]; substitutions = { - nugetSource = nuget-source; + runtimeId = lib.escapeShellArg runtimeId; dynamicLinker = "${stdenv.cc}/nix-support/dynamic-linker"; libPath = lib.makeLibraryPath [ stdenv.cc.cc.lib @@ -36,54 +27,44 @@ in zlib openssl ]; - inherit runtimeId; }; - } ./dotnet-configure-hook.sh) { }; + } + ./dotnet-configure-hook.sh; - dotnetBuildHook = callPackage ({ }: - makeSetupHook { + dotnetBuildHook = makeSetupHook + { name = "dotnet-build-hook"; - propagatedBuildInputs = [ dotnet-sdk ]; substitutions = { - inherit buildType runtimeId; + runtimeId = lib.escapeShellArg runtimeId; }; - } ./dotnet-build-hook.sh) { }; + } + ./dotnet-build-hook.sh; - dotnetCheckHook = callPackage ({ }: - makeSetupHook { + dotnetCheckHook = makeSetupHook + { name = "dotnet-check-hook"; - propagatedBuildInputs = [ dotnet-test-sdk ]; substitutions = { - inherit buildType runtimeId libraryPath; - disabledTests = lib.optionalString (disabledTests != []) - (let - escapedNames = lib.lists.map (n: lib.replaceStrings [","] ["%2C"] n) disabledTests; - filters = lib.lists.map (n: "FullyQualifiedName!=${n}") escapedNames; - in - "${lib.concatStringsSep "&" filters}"); + runtimeId = lib.escapeShellArg runtimeId; }; - } ./dotnet-check-hook.sh) { }; + } + ./dotnet-check-hook.sh; - dotnetInstallHook = callPackage ({ }: - makeSetupHook { + dotnetInstallHook = makeSetupHook + { name = "dotnet-install-hook"; - propagatedBuildInputs = [ dotnet-sdk ]; substitutions = { - inherit buildType runtimeId; + runtimeId = lib.escapeShellArg runtimeId; }; - } ./dotnet-install-hook.sh) { }; + } + ./dotnet-install-hook.sh; - dotnetFixupHook = callPackage ({ }: - makeSetupHook { + dotnetFixupHook = makeSetupHook + { name = "dotnet-fixup-hook"; - propagatedBuildInputs = [ dotnet-runtime ]; substitutions = { dotnetRuntime = dotnet-runtime; - runtimeDeps = libraryPath; - shell = stdenv.shell; - which = "${which}/bin/which"; - dirname = "${coreutils}/bin/dirname"; - realpath = "${coreutils}/bin/realpath"; + wrapperPath = lib.makeBinPath [ which coreutils ]; }; - } ./dotnet-fixup-hook.sh) { }; + } + ./dotnet-fixup-hook.sh; } diff --git a/pkgs/build-support/dotnet/build-dotnet-module/hooks/dotnet-build-hook.sh b/pkgs/build-support/dotnet/build-dotnet-module/hooks/dotnet-build-hook.sh index 0acfeced9b169..f209861f79b15 100644 --- a/pkgs/build-support/dotnet/build-dotnet-module/hooks/dotnet-build-hook.sh +++ b/pkgs/build-support/dotnet/build-dotnet-module/hooks/dotnet-build-hook.sh @@ -1,12 +1,25 @@ -# inherit arguments from derivation -dotnetBuildFlags=( ${dotnetBuildFlags[@]-} ) - dotnetBuildHook() { echo "Executing dotnetBuildHook" runHook preBuild - if [ "${enableParallelBuilding-}" ]; then + local -r hostRuntimeId=@runtimeId@ + local -r dotnetBuildType="${dotnetBuildType-Release}" + local -r dotnetRuntimeId="${dotnetRuntimeId-$hostRuntimeId}" + + if [[ -n $__structuredAttrs ]]; then + local dotnetProjectFilesArray=( "${dotnetProjectFiles[@]}" ) + local dotnetTestProjectFilesArray=( "${dotnetTestProjectFiles[@]}" ) + local dotnetFlagsArray=( "${dotnetFlags[@]}" ) + local dotnetBuildFlagsArray=( "${dotnetBuildFlags[@]}" ) + else + local dotnetProjectFilesArray=($dotnetProjectFiles) + local dotnetTestProjectFilesArray=($dotnetTestProjectFiles) + local dotnetFlagsArray=($dotnetFlags) + local dotnetBuildFlagsArray=($dotnetBuildFlags) + fi + + if [[ -n "${enableParallelBuilding-}" ]]; then local -r maxCpuFlag="$NIX_BUILD_CORES" local -r parallelBuildFlag="true" else @@ -14,50 +27,53 @@ dotnetBuildHook() { local -r parallelBuildFlag="false" fi - if [ "${selfContainedBuild-}" ]; then - dotnetBuildFlags+=("-p:SelfContained=true") + if [[ -n ${dotnetSelfContainedBuild-} ]]; then + dotnetBuildFlagsArray+=("-p:SelfContained=true") else - dotnetBuildFlags+=("-p:SelfContained=false") + dotnetBuildFlagsArray+=("-p:SelfContained=false") fi - if [ "${useAppHost-}" ]; then - dotnetBuildFlags+=("-p:UseAppHost=true") + if [[ -n ${dotnetUseAppHost-} ]]; then + dotnetBuildFlagsArray+=("-p:UseAppHost=true") fi - local versionFlags=() - if [ "${version-}" ]; then - versionFlags+=("-p:InformationalVersion=${version-}") + local versionFlagsArray=() + if [[ -n ${version-} ]]; then + versionFlagsArray+=("-p:InformationalVersion=$version") fi - if [ "${versionForDotnet-}" ]; then - versionFlags+=("-p:Version=${versionForDotnet-}") + if [[ -n ${versionForDotnet-} ]]; then + versionFlagsArray+=("-p:Version=$versionForDotnet") fi dotnetBuild() { - local -r project="${1-}" + local -r projectFile="${1-}" - runtimeIdFlags=() - if [[ "$project" == *.csproj ]] || [ "${selfContainedBuild-}" ]; then - runtimeIdFlags+=("--runtime @runtimeId@") + local runtimeIdFlagsArray=() + if [[ $projectFile == *.csproj || -n ${dotnetSelfContainedBuild-} ]]; then + runtimeIdFlagsArray+=("--runtime" "$dotnetRuntimeId") fi - env dotnet build ${project-} \ - -maxcpucount:$maxCpuFlag \ - -p:BuildInParallel=$parallelBuildFlag \ + dotnet build ${1+"$projectFile"} \ + -maxcpucount:"$maxCpuFlag" \ + -p:BuildInParallel="$parallelBuildFlag" \ -p:ContinuousIntegrationBuild=true \ -p:Deterministic=true \ - --configuration "@buildType@" \ + --configuration "$dotnetBuildType" \ --no-restore \ - ${versionFlags[@]} \ - ${runtimeIdFlags[@]} \ - ${dotnetBuildFlags[@]} \ - ${dotnetFlags[@]} + "${versionFlagsArray[@]}" \ + "${runtimeIdFlagsArray[@]}" \ + "${dotnetBuildFlagsArray[@]}" \ + "${dotnetFlagsArray[@]}" } - (( "${#projectFile[@]}" == 0 )) && dotnetBuild + if (( ${#dotnetProjectFilesArray[@]} == 0 )); then + dotnetBuild + fi - for project in ${projectFile[@]} ${testProjectFile[@]-}; do - dotnetBuild "$project" + local projectFile + for projectFile in "${dotnetProjectFilesArray[@]}" "${dotnetTestProjectFilesArray[@]}"; do + dotnetBuild "$projectFile" done runHook postBuild @@ -65,6 +81,6 @@ dotnetBuildHook() { echo "Finished dotnetBuildHook" } -if [[ -z "${dontDotnetBuild-}" && -z "${buildPhase-}" ]]; then +if [[ -z ${dontDotnetBuild-} && -z ${buildPhase-} ]]; then buildPhase=dotnetBuildHook fi diff --git a/pkgs/build-support/dotnet/build-dotnet-module/hooks/dotnet-check-hook.sh b/pkgs/build-support/dotnet/build-dotnet-module/hooks/dotnet-check-hook.sh index 507721ef98181..c91251f4f1807 100644 --- a/pkgs/build-support/dotnet/build-dotnet-module/hooks/dotnet-check-hook.sh +++ b/pkgs/build-support/dotnet/build-dotnet-module/hooks/dotnet-check-hook.sh @@ -1,39 +1,65 @@ -# inherit arguments from derivation -dotnetTestFlags=( ${dotnetTestFlags[@]-} ) - dotnetCheckHook() { echo "Executing dotnetCheckHook" runHook preCheck - if [ "${disabledTests-}" ]; then - local -r disabledTestsFlag="--filter @disabledTests@" + local -r hostRuntimeId=@runtimeId@ + local -r dotnetBuildType="${dotnetBuildType-Release}" + local -r dotnetRuntimeId="${dotnetRuntimeId-$hostRuntimeId}" + + if [[ -n $__structuredAttrs ]]; then + local dotnetProjectFilesArray=( "${dotnetProjectFiles[@]}" ) + local dotnetTestProjectFilesArray=( "${dotnetTestProjectFiles[@]}" ) + local dotnetTestFlagsArray=( "${dotnetTestFlags[@]}" ) + local dotnetDisabledTestsArray=( "${dotnetDisabledTests[@]}" ) + local dotnetRuntimeDepsArray=( "${dotnetRuntimeDeps[@]}" ) + else + local dotnetProjectFilesArray=($dotnetProjectFiles) + local dotnetTestProjectFilesArray=($dotnetTestProjectFiles) + local dotnetTestFlagsArray=($dotnetTestFlags) + local dotnetDisabledTestsArray=($dotnetDisabledTests) + local dotnetRuntimeDepsArray=($dotnetRuntimeDeps) + fi + + if (( ${#dotnetDisabledTestsArray[@]} > 0 )); then + local disabledTestsFilters=("${dotnetDisabledTestsArray[@]/#/FullyQualifiedName!=}") + local OLDIFS="$IFS" IFS='&' + dotnetTestFlagsArray+=("--filter:${disabledTestsFilters[*]//,/%2C}") + IFS="$OLDIFS" + fi + + local libraryPath="${LD_LIBRARY_PATH-}" + if (( ${#dotnetRuntimeDepsArray[@]} > 0 )); then + local libraryPathArray=("${dotnetRuntimeDepsArray[@]/%//lib}") + local OLDIFS="$IFS" IFS=':' + libraryPath="${libraryPathArray[*]}${libraryPath:+':'}$libraryPath" + IFS="$OLDIFS" fi - if [ "${enableParallelBuilding-}" ]; then + if [[ -n ${enableParallelBuilding-} ]]; then local -r maxCpuFlag="$NIX_BUILD_CORES" else local -r maxCpuFlag="1" fi - for project in ${testProjectFile[@]-${projectFile[@]}}; do - runtimeIdFlags=() - if [[ "$project" == *.csproj ]]; then - runtimeIdFlags=("--runtime @runtimeId@") + local projectFile + for projectFile in "${dotnetTestProjectFilesArray[@]-${dotnetProjectFilesArray[@]}}"; do + local runtimeIdFlagsArray=() + if [[ $projectFile == *.csproj ]]; then + runtimeIdFlagsArray=("--runtime" "$dotnetRuntimeId") fi - env "LD_LIBRARY_PATH=@libraryPath@" \ - dotnet test "$project" \ - -maxcpucount:$maxCpuFlag \ + LD_LIBRARY_PATH=$libraryPath \ + dotnet test "$projectFile" \ + -maxcpucount:"$maxCpuFlag" \ -p:ContinuousIntegrationBuild=true \ -p:Deterministic=true \ - --configuration "@buildType@" \ + --configuration "$dotnetBuildType" \ --no-build \ --logger "console;verbosity=normal" \ - ${disabledTestsFlag-} \ - ${runtimeIdFlags[@]} \ - "${dotnetTestFlags[@]}" \ - "${dotnetFlags[@]}" + "${runtimeIdFlagsArray[@]}" \ + "${dotnetTestFlagsArray[@]}" \ + "${dotnetFlagsArray[@]}" done runHook postCheck diff --git a/pkgs/build-support/dotnet/build-dotnet-module/hooks/dotnet-configure-hook.sh b/pkgs/build-support/dotnet/build-dotnet-module/hooks/dotnet-configure-hook.sh index c046fc3c306b1..12fa348699865 100644 --- a/pkgs/build-support/dotnet/build-dotnet-module/hooks/dotnet-configure-hook.sh +++ b/pkgs/build-support/dotnet/build-dotnet-module/hooks/dotnet-configure-hook.sh @@ -1,63 +1,103 @@ -declare -a projectFile testProjectFile - -# Inherit arguments from derivation -dotnetFlags=( ${dotnetFlags[@]-} ) -dotnetRestoreFlags=( ${dotnetRestoreFlags[@]-} ) - dotnetConfigureHook() { echo "Executing dotnetConfigureHook" runHook preConfigure - if [ -z "${enableParallelBuilding-}" ]; then + if [[ -z ${nugetSource-} ]]; then + echo + echo "ERROR: no dependencies were specified" + echo 'Hint: set `nugetSource` if using these hooks individually. If this is happening with `buildDotnetModule`, please open an issue.' + echo + + exit 1 + fi + + local nugetSourceSedQuoted="${nugetSource//[\/\\&$'\n']/\\&}" + local nugetSourceXMLQuoted="$nugetSource" + nugetSourceXMLQuoted="${nugetSource//&/\&}" + nugetSourceXMLQuoted="${nugetSourceXMLQuoted//\"/\"}" + + local -r hostRuntimeId=@runtimeId@ + local -r dynamicLinker=@dynamicLinker@ + local -r libPath=@libPath@ + local -r dotnetRuntimeId="${dotnetRuntimeId-$hostRuntimeId}" + + if [[ -n $__structuredAttrs ]]; then + local dotnetProjectFilesArray=( "${dotnetProjectFiles[@]}" ) + local dotnetTestProjectFilesArray=( "${dotnetTestProjectFiles[@]}" ) + local dotnetFlagsArray=( "${dotnetFlags[@]}" ) + local dotnetRestoreFlagsArray=( "${dotnetRestoreFlags[@]}" ) + else + local dotnetProjectFilesArray=($dotnetProjectFiles) + local dotnetTestProjectFilesArray=($dotnetTestProjectFiles) + local dotnetFlagsArray=($dotnetFlags) + local dotnetRestoreFlagsArray=($dotnetRestoreFlags) + fi + + if [[ -z ${enableParallelBuilding-} ]]; then local -r parallelFlag="--disable-parallel" fi dotnetRestore() { - local -r project="${1-}" - env dotnet restore ${project-} \ + local -r projectFile="${1-}" + dotnet restore ${1+"$projectFile"} \ -p:ContinuousIntegrationBuild=true \ -p:Deterministic=true \ - --runtime "@runtimeId@" \ - --source "@nugetSource@/lib" \ + --runtime "$dotnetRuntimeId" \ + --source "$nugetSource/lib" \ ${parallelFlag-} \ - ${dotnetRestoreFlags[@]} \ - ${dotnetFlags[@]} + "${dotnetRestoreFlagsArray[@]}" \ + "${dotnetFlagsArray[@]}" } # Generate a NuGet.config file to make sure everything, # including things like <Sdk /> dependencies, is restored from the proper source -cat <<EOF > "./NuGet.config" + cat >NuGet.config <<EOF <?xml version="1.0" encoding="utf-8"?> <configuration> <packageSources> <clear /> - <add key="nugetSource" value="@nugetSource@/lib" /> + <add key="nugetSource" value="$nugetSourceXMLQuoted/lib" /> </packageSources> </configuration> EOF - # Patch paket.dependencies and paket.lock (if found) to use the proper source. This ensures - # paket restore works correctly - # We use + instead of / in sed to avoid problems with slashes - find -name paket.dependencies -exec sed -i 's+source .*+source @nugetSource@/lib+g' {} \; - find -name paket.lock -exec sed -i 's+remote:.*+remote: @nugetSource@/lib+g' {} \; - - env dotnet tool restore --add-source "@nugetSource@/lib" - - (( "${#projectFile[@]}" == 0 )) && dotnetRestore + # Patch paket.dependencies and paket.lock (if found) to use the proper + # source. This ensures paket restore works correctly. Note that the + # nugetSourceSedQuoted abomination below safely escapes nugetSource string + # for use as a sed replacement string to avoid issues with slashes and other + # special characters ('&', '\\' and '\n'). + find -name paket.dependencies -exec sed -i "s/source .*/source $nugetSourceSedQuoted\/lib/g" {} \; + find -name paket.lock -exec sed -i "s/remote:.*/remote: $nugetSourceSedQuoted\/lib/g" {} \; + + dotnet tool restore --add-source "$nugetSource/lib" + + # dotnetGlobalTool is set in buildDotnetGlobalTool to patch dependencies but + # avoid other project-specific logic. This is a hack, but the old behavior + # is worse as it relied on a bug: setting projectFile to an empty string + # made the hooks actually skip all project-specific logic. It’s hard to keep + # backwards compatibility with this odd behavior now since we are using + # arrays, so instead we just pass a variable to indicate that we don’t have + # projects. + if [[ -z ${dotnetGlobalTool-} ]]; then + if (( ${#dotnetProjectFilesArray[@]} == 0 )); then + dotnetRestore + fi - for project in ${projectFile[@]} ${testProjectFile[@]-}; do - dotnetRestore "$project" - done + local projectFile + for projectFile in "${dotnetProjectFilesArray[@]}" "${dotnetTestProjectFilesArray[@]}"; do + dotnetRestore "$projectFile" + done + fi echo "Fixing up native binaries..." # Find all native binaries and nuget libraries, and fix them up, # by setting the proper interpreter and rpath to some commonly used libraries + local binary for binary in $(find "$HOME/.nuget/packages/" -type f -executable); do if patchelf --print-interpreter "$binary" >/dev/null 2>/dev/null; then echo "Found binary: $binary, fixing it up..." - patchelf --set-interpreter "$(cat "@dynamicLinker@")" "$binary" + patchelf --set-interpreter "$(cat "$dynamicLinker")" "$binary" # This makes sure that if the binary requires some specific runtime dependencies, it can find it. # This fixes dotnet-built binaries like crossgen2 @@ -68,7 +108,7 @@ EOF --add-needed libssl.so \ "$binary" - patchelf --set-rpath "@libPath@" "$binary" + patchelf --set-rpath "$libPath" "$binary" fi done diff --git a/pkgs/build-support/dotnet/build-dotnet-module/hooks/dotnet-fixup-hook.sh b/pkgs/build-support/dotnet/build-dotnet-module/hooks/dotnet-fixup-hook.sh index e3671728af35e..a9701f2898b27 100644 --- a/pkgs/build-support/dotnet/build-dotnet-module/hooks/dotnet-fixup-hook.sh +++ b/pkgs/build-support/dotnet/build-dotnet-module/hooks/dotnet-fixup-hook.sh @@ -1,26 +1,60 @@ -# Inherit arguments from the derivation -declare -a derivationMakeWrapperArgs="( ${makeWrapperArgs-} )" -makeWrapperArgs=( "${derivationMakeWrapperArgs[@]}" ) +# For compatibility, convert makeWrapperArgs to an array unless we are using +# structured attributes. That is, we ensure that makeWrapperArgs is always an +# array. +# See https://github.com/NixOS/nixpkgs/blob/858f4db3048c5be3527e183470e93c1a72c5727c/pkgs/build-support/dotnet/build-dotnet-module/hooks/dotnet-fixup-hook.sh#L1-L3 +# and https://github.com/NixOS/nixpkgs/pull/313005#issuecomment-2175482920 +if [[ -z $__structuredAttrs ]]; then + makeWrapperArgs=( ${makeWrapperArgs-} ) +fi # First argument is the executable you want to wrap, # the second is the destination for the wrapper. wrapDotnetProgram() { - local dotnetRootFlags=() + local -r dotnetRuntime=@dotnetRuntime@ + local -r wrapperPath=@wrapperPath@ + + local -r dotnetFromEnvScript='dotnetFromEnv() { + local dotnetPath + if command -v dotnet 2>&1 >/dev/null; then + dotnetPath=$(which dotnet) && \ + dotnetPath=$(realpath "$dotnetPath") && \ + dotnetPath=$(dirname "$dotnetPath") && \ + export DOTNET_ROOT="$dotnetPath" + fi +} +dotnetFromEnv' + + if [[ -n $__structuredAttrs ]]; then + local -r dotnetRuntimeDepsArray=( "${dotnetRuntimeDeps[@]}" ) + else + local -r dotnetRuntimeDepsArray=($dotnetRuntimeDeps) + fi - if [ ! "${selfContainedBuild-}" ]; then - if [ "${useDotnetFromEnv-}" ]; then + local dotnetRuntimeDepsFlags=() + if (( ${#dotnetRuntimeDepsArray[@]} > 0 )); then + local libraryPathArray=("${dotnetRuntimeDepsArray[@]/%//lib}") + local OLDIFS="$IFS" IFS=':' + dotnetRuntimeDepsFlags+=("--suffix" "LD_LIBRARY_PATH" ":" "${libraryPathArray[*]}") + IFS="$OLDIFS" + fi + + local dotnetRootFlagsArray=() + if [[ -z ${dotnetSelfContainedBuild-} ]]; then + if [[ -n ${useDotnetFromEnv-} ]]; then # if dotnet CLI is available, set DOTNET_ROOT based on it. Otherwise set to default .NET runtime - dotnetRootFlags+=("--run" 'command -v dotnet &>/dev/null && export DOTNET_ROOT="$(@dirname@ "$(@realpath@ "$(@which@ dotnet)")")" || export DOTNET_ROOT="@dotnetRuntime@"') - dotnetRootFlags+=("--suffix" "PATH" ":" "@dotnetRuntime@/bin") + dotnetRootFlagsArray+=("--suffix" "PATH" ":" "$wrapperPath") + dotnetRootFlagsArray+=("--run" "$dotnetFromEnvScript") + dotnetRootFlagsArray+=("--set-default" "DOTNET_ROOT" "$dotnetRuntime") + dotnetRootFlagsArray+=("--suffix" "PATH" ":" "$dotnetRuntime/bin") else - dotnetRootFlags+=("--set" "DOTNET_ROOT" "@dotnetRuntime@") - dotnetRootFlags+=("--prefix" "PATH" ":" "@dotnetRuntime@/bin") + dotnetRootFlagsArray+=("--set" "DOTNET_ROOT" "$dotnetRuntime") + dotnetRootFlagsArray+=("--prefix" "PATH" ":" "$dotnetRuntime/bin") fi fi makeWrapper "$1" "$2" \ - --suffix "LD_LIBRARY_PATH" : "@runtimeDeps@" \ - "${dotnetRootFlags[@]}" \ + "${dotnetRuntimeDepsFlags[@]}" \ + "${dotnetRootFlagsArray[@]}" \ "${gappsWrapperArgs[@]}" \ "${makeWrapperArgs[@]}" @@ -30,13 +64,24 @@ wrapDotnetProgram() { dotnetFixupHook() { echo "Executing dotnetFixupPhase" - # check if executables is declared (including empty values, in which case we generate no executables) - if declare -p executables &>/dev/null; then - for executable in ${executables[@]}; do - path="${installPath-$out/lib/$pname}/$executable" + local -r dotnetInstallPath="${dotnetInstallPath-$out/lib/$pname}" + + local executable executableBasename + + # check if dotnetExecutables is declared (including empty values, in which case we generate no executables) + if declare -p dotnetExecutables &>/dev/null; then + if [[ -n $__structuredAttrs ]]; then + local dotnetExecutablesArray=( "${dotnetExecutables[@]}" ) + else + local dotnetExecutablesArray=($dotnetExecutables) + fi + for executable in "${dotnetExecutablesArray[@]}"; do + executableBasename=$(basename "$executable") + + local path="$dotnetInstallPath/$executable" if test -x "$path"; then - wrapDotnetProgram "$path" "$out/bin/$(basename "$executable")" + wrapDotnetProgram "$path" "$out/bin/$executableBasename" else echo "Specified binary \"$executable\" is either not an executable or does not exist!" echo "Looked in $path" @@ -45,8 +90,9 @@ dotnetFixupHook() { done else while IFS= read -d '' executable; do - wrapDotnetProgram "$executable" "$out/bin/$(basename "$executable")" \; - done < <(find "${installPath-$out/lib/$pname}" ! -name "*.dll" -executable -type f -print0) + executableBasename=$(basename "$executable") + wrapDotnetProgram "$executable" "$out/bin/$executableBasename" \; + done < <(find "$dotnetInstallPath" ! -name "*.dll" -executable -type f -print0) fi echo "Finished dotnetFixupPhase" diff --git a/pkgs/build-support/dotnet/build-dotnet-module/hooks/dotnet-install-hook.sh b/pkgs/build-support/dotnet/build-dotnet-module/hooks/dotnet-install-hook.sh index d832eac288096..4d9b3c502c354 100644 --- a/pkgs/build-support/dotnet/build-dotnet-module/hooks/dotnet-install-hook.sh +++ b/pkgs/build-support/dotnet/build-dotnet-module/hooks/dotnet-install-hook.sh @@ -1,70 +1,86 @@ -# inherit arguments from derivation -dotnetInstallFlags=( ${dotnetInstallFlags[@]-} ) - dotnetInstallHook() { echo "Executing dotnetInstallHook" runHook preInstall - if [ "${selfContainedBuild-}" ]; then - dotnetInstallFlags+=("--self-contained") + local -r hostRuntimeId=@runtimeId@ + local -r dotnetInstallPath="${dotnetInstallPath-$out/lib/$pname}" + local -r dotnetBuildType="${dotnetBuildType-Release}" + local -r dotnetRuntimeId="${dotnetRuntimeId-$hostRuntimeId}" + + if [[ -n $__structuredAttrs ]]; then + local dotnetProjectFilesArray=( "${dotnetProjectFiles[@]}" ) + local dotnetFlagsArray=( "${dotnetFlags[@]}" ) + local dotnetInstallFlagsArray=( "${dotnetInstallFlags[@]}" ) + local dotnetPackFlagsArray=( "${dotnetPackFlags[@]}" ) + else + local dotnetProjectFilesArray=($dotnetProjectFiles) + local dotnetFlagsArray=($dotnetFlags) + local dotnetInstallFlagsArray=($dotnetInstallFlags) + local dotnetPackFlagsArray=($dotnetPackFlags) + fi + + if [[ -n ${dotnetSelfContainedBuild-} ]]; then + dotnetInstallFlagsArray+=("--self-contained") else - dotnetInstallFlags+=("--no-self-contained") + dotnetInstallFlagsArray+=("--no-self-contained") # https://learn.microsoft.com/en-us/dotnet/core/deploying/trimming/trim-self-contained # Trimming is only available for self-contained build, so force disable it here - dotnetInstallFlags+=("-p:PublishTrimmed=false") + dotnetInstallFlagsArray+=("-p:PublishTrimmed=false") fi - if [ "${useAppHost-}" ]; then - dotnetInstallFlags+=("-p:UseAppHost=true") + if [[ -n ${dotnetUseAppHost-} ]]; then + dotnetInstallFlagsArray+=("-p:UseAppHost=true") fi dotnetPublish() { - local -r project="${1-}" + local -r projectFile="${1-}" - runtimeIdFlags=() - if [[ "$project" == *.csproj ]] || [ "${selfContainedBuild-}" ]; then - runtimeIdFlags+=("--runtime @runtimeId@") + runtimeIdFlagsArray=() + if [[ $projectFile == *.csproj || -n ${dotnetSelfContainedBuild-} ]]; then + runtimeIdFlagsArray+=("--runtime" "$dotnetRuntimeId") fi - env dotnet publish ${project-} \ + dotnet publish ${1+"$projectFile"} \ -p:ContinuousIntegrationBuild=true \ -p:Deterministic=true \ - --output "${installPath-$out/lib/$pname}" \ - --configuration "@buildType@" \ + --output "$dotnetInstallPath" \ + --configuration "$dotnetBuildType" \ --no-build \ - ${runtimeIdFlags[@]} \ - ${dotnetInstallFlags[@]} \ - ${dotnetFlags[@]} + "${runtimeIdFlagsArray[@]}" \ + "${dotnetInstallFlagsArray[@]}" \ + "${dotnetFlagsArray[@]}" } dotnetPack() { - local -r project="${1-}" - env dotnet pack ${project-} \ + local -r projectFile="${1-}" + dotnet pack ${1+"$projectFile"} \ -p:ContinuousIntegrationBuild=true \ -p:Deterministic=true \ --output "$out/share" \ - --configuration "@buildType@" \ + --configuration "$dotnetBuildType" \ --no-build \ - --runtime "@runtimeId@" \ - ${dotnetPackFlags[@]} \ - ${dotnetFlags[@]} + --runtime "$dotnetRuntimeId" \ + "${dotnetPackFlagsArray[@]}" \ + "${dotnetFlagsArray[@]}" } - if (( "${#projectFile[@]}" == 0 )); then + if (( ${#dotnetProjectFilesArray[@]} == 0 )); then dotnetPublish else - for project in ${projectFile[@]}; do - dotnetPublish "$project" + local projectFile + for projectFile in "${dotnetProjectFilesArray[@]}"; do + dotnetPublish "$projectFile" done fi - if [[ "${packNupkg-}" ]]; then - if (( "${#projectFile[@]}" == 0 )); then + if [[ -n ${packNupkg-} ]]; then + if (( ${#dotnetProjectFilesArray[@]} == 0 )); then dotnetPack else - for project in ${projectFile[@]}; do - dotnetPack "$project" + local projectFile + for projectFile in "${dotnetProjectFilesArray[@]}"; do + dotnetPack "$projectFile" done fi fi |