···
1
+
dotnetConfigureHook() {
2
+
echo "Executing dotnetConfigureHook"
6
+
local -r dynamicLinker=@dynamicLinker@
7
+
local -r libPath=@libPath@
9
+
if [[ -n $__structuredAttrs ]]; then
10
+
local dotnetProjectFilesArray=( "${dotnetProjectFiles[@]}" )
11
+
local dotnetTestProjectFilesArray=( "${dotnetTestProjectFiles[@]}" )
12
+
local dotnetFlagsArray=( "${dotnetFlags[@]}" )
13
+
local dotnetRestoreFlagsArray=( "${dotnetRestoreFlags[@]}" )
14
+
local dotnetRuntimeIdsArray=( "${dotnetRuntimeIds[@]}" )
16
+
local dotnetProjectFilesArray=($dotnetProjectFiles)
17
+
local dotnetTestProjectFilesArray=($dotnetTestProjectFiles)
18
+
local dotnetFlagsArray=($dotnetFlags)
19
+
local dotnetRestoreFlagsArray=($dotnetRestoreFlags)
20
+
local dotnetRuntimeIdsArray=($dotnetRuntimeIds)
23
+
if [[ -z ${enableParallelBuilding-} ]]; then
24
+
local -r parallelFlag="--disable-parallel"
27
+
if [[ -v dotnetSelfContainedBuild ]]; then
28
+
if [[ -n $dotnetSelfContainedBuild ]]; then
29
+
dotnetRestoreFlagsArray+=("-p:SelfContained=true")
31
+
dotnetRestoreFlagsArray+=("-p:SelfContained=false")
36
+
local -r projectFile="${1-}"
37
+
for runtimeId in "${dotnetRuntimeIdsArray[@]}"; do
38
+
dotnet restore ${1+"$projectFile"} \
39
+
-p:ContinuousIntegrationBuild=true \
40
+
-p:Deterministic=true \
41
+
-p:NuGetAudit=false \
42
+
--runtime "$runtimeId" \
44
+
"${dotnetRestoreFlagsArray[@]}" \
45
+
"${dotnetFlagsArray[@]}"
49
+
if [[ -f .config/dotnet-tools.json || -f dotnet-tools.json ]]; then
53
+
# dotnetGlobalTool is set in buildDotnetGlobalTool to patch dependencies but
54
+
# avoid other project-specific logic. This is a hack, but the old behavior
55
+
# is worse as it relied on a bug: setting projectFile to an empty string
56
+
# made the hooks actually skip all project-specific logic. It’s hard to keep
57
+
# backwards compatibility with this odd behavior now since we are using
58
+
# arrays, so instead we just pass a variable to indicate that we don’t have
60
+
if [[ -z ${dotnetGlobalTool-} ]]; then
61
+
if (( ${#dotnetProjectFilesArray[@]} == 0 )); then
66
+
for projectFile in "${dotnetProjectFilesArray[@]}" "${dotnetTestProjectFilesArray[@]}"; do
67
+
dotnetRestore "$projectFile"
71
+
runHook postConfigure
73
+
echo "Finished dotnetConfigureHook"
76
+
if [[ -z "${dontDotnetConfigure-}" && -z "${configurePhase-}" ]]; then
77
+
configurePhase=dotnetConfigureHook
81
+
echo "Executing dotnetBuildHook"
85
+
local -r dotnetBuildType="${dotnetBuildType-Release}"
87
+
if [[ -n $__structuredAttrs ]]; then
88
+
local dotnetProjectFilesArray=( "${dotnetProjectFiles[@]}" )
89
+
local dotnetTestProjectFilesArray=( "${dotnetTestProjectFiles[@]}" )
90
+
local dotnetFlagsArray=( "${dotnetFlags[@]}" )
91
+
local dotnetBuildFlagsArray=( "${dotnetBuildFlags[@]}" )
92
+
local dotnetRuntimeIdsArray=( "${dotnetRuntimeIds[@]}" )
94
+
local dotnetProjectFilesArray=($dotnetProjectFiles)
95
+
local dotnetTestProjectFilesArray=($dotnetTestProjectFiles)
96
+
local dotnetFlagsArray=($dotnetFlags)
97
+
local dotnetBuildFlagsArray=($dotnetBuildFlags)
98
+
local dotnetRuntimeIdsArray=($dotnetRuntimeIds)
101
+
if [[ -n "${enableParallelBuilding-}" ]]; then
102
+
local -r maxCpuFlag="$NIX_BUILD_CORES"
103
+
local -r parallelBuildFlag="true"
105
+
local -r maxCpuFlag="1"
106
+
local -r parallelBuildFlag="false"
109
+
if [[ -v dotnetSelfContainedBuild ]]; then
110
+
if [[ -n $dotnetSelfContainedBuild ]]; then
111
+
dotnetBuildFlagsArray+=("-p:SelfContained=true")
113
+
dotnetBuildFlagsArray+=("-p:SelfContained=false")
117
+
if [[ -n ${dotnetUseAppHost-} ]]; then
118
+
dotnetBuildFlagsArray+=("-p:UseAppHost=true")
121
+
local versionFlagsArray=()
122
+
if [[ -n ${version-} ]]; then
123
+
versionFlagsArray+=("-p:InformationalVersion=$version")
126
+
if [[ -n ${versionForDotnet-} ]]; then
127
+
versionFlagsArray+=("-p:Version=$versionForDotnet")
131
+
local -r projectFile="${1-}"
133
+
for runtimeId in "${dotnetRuntimeIdsArray[@]}"; do
134
+
local runtimeIdFlagsArray=()
135
+
if [[ $projectFile == *.csproj || -n ${dotnetSelfContainedBuild-} ]]; then
136
+
runtimeIdFlagsArray+=("--runtime" "$runtimeId")
139
+
dotnet build ${1+"$projectFile"} \
140
+
-maxcpucount:"$maxCpuFlag" \
141
+
-p:BuildInParallel="$parallelBuildFlag" \
142
+
-p:ContinuousIntegrationBuild=true \
143
+
-p:Deterministic=true \
144
+
-p:OverwriteReadOnlyFiles=true \
145
+
--configuration "$dotnetBuildType" \
147
+
"${versionFlagsArray[@]}" \
148
+
"${runtimeIdFlagsArray[@]}" \
149
+
"${dotnetBuildFlagsArray[@]}" \
150
+
"${dotnetFlagsArray[@]}"
154
+
if (( ${#dotnetProjectFilesArray[@]} == 0 )); then
159
+
for projectFile in "${dotnetProjectFilesArray[@]}" "${dotnetTestProjectFilesArray[@]}"; do
160
+
dotnetBuild "$projectFile"
165
+
echo "Finished dotnetBuildHook"
168
+
if [[ -z ${dontDotnetBuild-} && -z ${buildPhase-} ]]; then
169
+
buildPhase=dotnetBuildHook
172
+
dotnetCheckHook() {
173
+
echo "Executing dotnetCheckHook"
177
+
local -r dotnetBuildType="${dotnetBuildType-Release}"
179
+
if [[ -n $__structuredAttrs ]]; then
180
+
local dotnetProjectFilesArray=( "${dotnetProjectFiles[@]}" )
181
+
local dotnetTestProjectFilesArray=( "${dotnetTestProjectFiles[@]}" )
182
+
local dotnetTestFlagsArray=( "${dotnetTestFlags[@]}" )
183
+
local dotnetTestFiltersArray=( "${dotnetTestFilters[@]}" )
184
+
local dotnetDisabledTestsArray=( "${dotnetDisabledTests[@]}" )
185
+
local dotnetRuntimeDepsArray=( "${dotnetRuntimeDeps[@]}" )
186
+
local dotnetRuntimeIdsArray=( "${dotnetRuntimeIds[@]}" )
188
+
local dotnetProjectFilesArray=($dotnetProjectFiles)
189
+
local dotnetTestProjectFilesArray=($dotnetTestProjectFiles)
190
+
local dotnetTestFlagsArray=($dotnetTestFlags)
191
+
local dotnetTestFiltersArray=($dotnetTestFilters)
192
+
local dotnetDisabledTestsArray=($dotnetDisabledTests)
193
+
local dotnetRuntimeDepsArray=($dotnetRuntimeDeps)
194
+
local dotnetRuntimeIdsArray=($dotnetRuntimeIds)
197
+
if (( ${#dotnetDisabledTestsArray[@]} > 0 )); then
198
+
local disabledTestsFilters=("${dotnetDisabledTestsArray[@]/#/FullyQualifiedName!=}")
199
+
dotnetTestFiltersArray=( "${dotnetTestFiltersArray[@]}" "${disabledTestsFilters[@]//,/%2C}" )
202
+
if (( ${#dotnetTestFiltersArray[@]} > 0 )); then
203
+
local OLDIFS="$IFS" IFS='&'
204
+
dotnetTestFlagsArray+=("--filter:${dotnetTestFiltersArray[*]}")
208
+
local libraryPath="${LD_LIBRARY_PATH-}"
209
+
if (( ${#dotnetRuntimeDepsArray[@]} > 0 )); then
210
+
local libraryPathArray=("${dotnetRuntimeDepsArray[@]/%//lib}")
211
+
local OLDIFS="$IFS" IFS=':'
212
+
libraryPath="${libraryPathArray[*]}${libraryPath:+':'}$libraryPath"
216
+
if [[ -n ${enableParallelBuilding-} ]]; then
217
+
local -r maxCpuFlag="$NIX_BUILD_CORES"
219
+
local -r maxCpuFlag="1"
222
+
local projectFile runtimeId
223
+
for projectFile in "${dotnetTestProjectFilesArray[@]-${dotnetProjectFilesArray[@]}}"; do
224
+
for runtimeId in "${dotnetRuntimeIdsArray[@]}"; do
225
+
local runtimeIdFlagsArray=()
226
+
if [[ $projectFile == *.csproj ]]; then
227
+
runtimeIdFlagsArray=("--runtime" "$runtimeId")
230
+
LD_LIBRARY_PATH=$libraryPath \
231
+
dotnet test "$projectFile" \
232
+
-maxcpucount:"$maxCpuFlag" \
233
+
-p:ContinuousIntegrationBuild=true \
234
+
-p:Deterministic=true \
235
+
--configuration "$dotnetBuildType" \
238
+
--logger "console;verbosity=normal" \
239
+
"${runtimeIdFlagsArray[@]}" \
240
+
"${dotnetTestFlagsArray[@]}" \
241
+
"${dotnetFlagsArray[@]}"
247
+
echo "Finished dotnetCheckHook"
250
+
if [[ -z "${dontDotnetCheck-}" && -z "${checkPhase-}" ]]; then
251
+
checkPhase=dotnetCheckHook
254
+
# For compatibility, convert makeWrapperArgs to an array unless we are using
255
+
# structured attributes. That is, we ensure that makeWrapperArgs is always an
257
+
# See https://github.com/NixOS/nixpkgs/blob/858f4db3048c5be3527e183470e93c1a72c5727c/pkgs/build-support/dotnet/build-dotnet-module/hooks/dotnet-fixup-hook.sh#L1-L3
258
+
# and https://github.com/NixOS/nixpkgs/pull/313005#issuecomment-2175482920
259
+
if [[ -z $__structuredAttrs ]]; then
260
+
makeWrapperArgs=( ${makeWrapperArgs-} )
263
+
# First argument is the executable you want to wrap,
264
+
# the second is the destination for the wrapper.
265
+
wrapDotnetProgram() {
266
+
local -r dotnetRuntime=@dotnetRuntime@
267
+
local -r wrapperPath=@wrapperPath@
269
+
local -r dotnetFromEnvScript='dotnetFromEnv() {
271
+
if command -v dotnet 2>&1 >/dev/null; then
272
+
dotnetPath=$(which dotnet) && \
273
+
dotnetPath=$(realpath "$dotnetPath") && \
274
+
dotnetPath=$(dirname "$dotnetPath") && \
275
+
export DOTNET_ROOT="$dotnetPath"
280
+
if [[ -n $__structuredAttrs ]]; then
281
+
local -r dotnetRuntimeDepsArray=( "${dotnetRuntimeDeps[@]}" )
283
+
local -r dotnetRuntimeDepsArray=($dotnetRuntimeDeps)
286
+
local dotnetRuntimeDepsFlags=()
287
+
if (( ${#dotnetRuntimeDepsArray[@]} > 0 )); then
288
+
local libraryPathArray=("${dotnetRuntimeDepsArray[@]/%//lib}")
289
+
local OLDIFS="$IFS" IFS=':'
290
+
dotnetRuntimeDepsFlags+=("--suffix" "LD_LIBRARY_PATH" ":" "${libraryPathArray[*]}")
294
+
local dotnetRootFlagsArray=()
295
+
if [[ -z ${dotnetSelfContainedBuild-} ]]; then
296
+
if [[ -n ${useDotnetFromEnv-} ]]; then
297
+
# if dotnet CLI is available, set DOTNET_ROOT based on it. Otherwise set to default .NET runtime
298
+
dotnetRootFlagsArray+=("--suffix" "PATH" ":" "$wrapperPath")
299
+
dotnetRootFlagsArray+=("--run" "$dotnetFromEnvScript")
300
+
if [[ -n $dotnetRuntime ]]; then
301
+
dotnetRootFlagsArray+=("--set-default" "DOTNET_ROOT" "$dotnetRuntime/share/dotnet")
302
+
dotnetRootFlagsArray+=("--suffix" "PATH" ":" "$dotnetRuntime/bin")
304
+
elif [[ -n $dotnetRuntime ]]; then
305
+
dotnetRootFlagsArray+=("--set" "DOTNET_ROOT" "$dotnetRuntime/share/dotnet")
306
+
dotnetRootFlagsArray+=("--prefix" "PATH" ":" "$dotnetRuntime/bin")
310
+
makeWrapper "$1" "$2" \
311
+
"${dotnetRuntimeDepsFlags[@]}" \
312
+
"${dotnetRootFlagsArray[@]}" \
313
+
"${gappsWrapperArgs[@]}" \
314
+
"${makeWrapperArgs[@]}"
316
+
echo "installed wrapper to "$2""
319
+
dotnetFixupHook() {
320
+
local -r dotnetInstallPath="${dotnetInstallPath-$out/lib/$pname}"
322
+
local executable executableBasename
324
+
# check if dotnetExecutables is declared (including empty values, in which case we generate no executables)
325
+
if declare -p dotnetExecutables &>/dev/null; then
326
+
if [[ -n $__structuredAttrs ]]; then
327
+
local dotnetExecutablesArray=( "${dotnetExecutables[@]}" )
329
+
local dotnetExecutablesArray=($dotnetExecutables)
331
+
for executable in "${dotnetExecutablesArray[@]}"; do
332
+
executableBasename=$(basename "$executable")
334
+
local path="$dotnetInstallPath/$executable"
336
+
if test -x "$path"; then
337
+
wrapDotnetProgram "$path" "$out/bin/$executableBasename"
339
+
echo "Specified binary \"$executable\" is either not an executable or does not exist!"
340
+
echo "Looked in $path"
345
+
while IFS= read -d '' executable; do
346
+
executableBasename=$(basename "$executable")
347
+
wrapDotnetProgram "$executable" "$out/bin/$executableBasename" \;
348
+
done < <(find "$dotnetInstallPath" ! -name "*.dll" -executable -type f -print0)
352
+
if [[ -z "${dontFixup-}" && -z "${dontDotnetFixup-}" ]]; then
353
+
appendToVar preFixupPhases dotnetFixupHook
356
+
dotnetInstallHook() {
357
+
echo "Executing dotnetInstallHook"
361
+
local -r dotnetInstallPath="${dotnetInstallPath-$out/lib/$pname}"
362
+
local -r dotnetBuildType="${dotnetBuildType-Release}"
364
+
if [[ -n $__structuredAttrs ]]; then
365
+
local dotnetProjectFilesArray=( "${dotnetProjectFiles[@]}" )
366
+
local dotnetFlagsArray=( "${dotnetFlags[@]}" )
367
+
local dotnetInstallFlagsArray=( "${dotnetInstallFlags[@]}" )
368
+
local dotnetPackFlagsArray=( "${dotnetPackFlags[@]}" )
369
+
local dotnetRuntimeIdsArray=( "${dotnetRuntimeIds[@]}" )
371
+
local dotnetProjectFilesArray=($dotnetProjectFiles)
372
+
local dotnetFlagsArray=($dotnetFlags)
373
+
local dotnetInstallFlagsArray=($dotnetInstallFlags)
374
+
local dotnetPackFlagsArray=($dotnetPackFlags)
375
+
local dotnetRuntimeIdsArray=($dotnetRuntimeIds)
378
+
if [[ -v dotnetSelfContainedBuild ]]; then
379
+
if [[ -n $dotnetSelfContainedBuild ]]; then
380
+
dotnetInstallFlagsArray+=("--self-contained")
382
+
dotnetInstallFlagsArray+=("--no-self-contained")
383
+
# https://learn.microsoft.com/en-us/dotnet/core/deploying/trimming/trim-self-contained
384
+
# Trimming is only available for self-contained build, so force disable it here
385
+
dotnetInstallFlagsArray+=("-p:PublishTrimmed=false")
389
+
if [[ -n ${dotnetUseAppHost-} ]]; then
390
+
dotnetInstallFlagsArray+=("-p:UseAppHost=true")
393
+
if [[ -n ${enableParallelBuilding-} ]]; then
394
+
local -r maxCpuFlag="$NIX_BUILD_CORES"
396
+
local -r maxCpuFlag="1"
400
+
local -r projectFile="${1-}"
402
+
for runtimeId in "${dotnetRuntimeIdsArray[@]}"; do
403
+
runtimeIdFlagsArray=()
404
+
if [[ $projectFile == *.csproj || -n ${dotnetSelfContainedBuild-} ]]; then
405
+
runtimeIdFlagsArray+=("--runtime" "$runtimeId")
408
+
dotnet publish ${1+"$projectFile"} \
409
+
-maxcpucount:"$maxCpuFlag" \
410
+
-p:ContinuousIntegrationBuild=true \
411
+
-p:Deterministic=true \
412
+
-p:OverwriteReadOnlyFiles=true \
413
+
--output "$dotnetInstallPath" \
414
+
--configuration "$dotnetBuildType" \
417
+
"${runtimeIdFlagsArray[@]}" \
418
+
"${dotnetInstallFlagsArray[@]}" \
419
+
"${dotnetFlagsArray[@]}"
424
+
local -r projectFile="${1-}"
426
+
for runtimeId in "${dotnetRuntimeIdsArray[@]}"; do
427
+
dotnet pack ${1+"$projectFile"} \
428
+
-maxcpucount:"$maxCpuFlag" \
429
+
-p:ContinuousIntegrationBuild=true \
430
+
-p:Deterministic=true \
431
+
-p:OverwriteReadOnlyFiles=true \
432
+
--output "$out/share/nuget/source" \
433
+
--configuration "$dotnetBuildType" \
436
+
--runtime "$runtimeId" \
437
+
"${dotnetPackFlagsArray[@]}" \
438
+
"${dotnetFlagsArray[@]}"
442
+
if (( ${#dotnetProjectFilesArray[@]} == 0 )); then
446
+
for projectFile in "${dotnetProjectFilesArray[@]}"; do
447
+
dotnetPublish "$projectFile"
451
+
if [[ -n ${packNupkg-} ]]; then
452
+
if (( ${#dotnetProjectFilesArray[@]} == 0 )); then
456
+
for projectFile in "${dotnetProjectFilesArray[@]}"; do
457
+
dotnetPack "$projectFile"
462
+
runHook postInstall
464
+
echo "Finished dotnetInstallHook"
467
+
if [[ -z "${dontDotnetInstall-}" && -z "${installPhase-}" ]]; then
468
+
installPhase=dotnetInstallHook
pyrox.dev