···161161162162- `services.dnscrypt-proxy2` gains a `package` option to specify dnscrypt-proxy package to use.
163163164164+- `services.nextcloud.configureRedis` now defaults to `true` in accordance with upstream recommendations to have caching for file locking. See the [upstream doc](https://docs.nextcloud.com/server/31/admin_manual/configuration_files/files_locking_transactional.html) for further details.
165165+164166- `services.gitea` supports sending notifications with sendmail again. To do this, activate the parameter `services.gitea.mailerUseSendmail` and configure SMTP server.
165167166168- `libvirt` now supports using `nftables` backend.
···772772773773 configureRedis = lib.mkOption {
774774 type = lib.types.bool;
775775- default = config.services.nextcloud.notify_push.enable;
776776- defaultText = lib.literalExpression "config.services.nextcloud.notify_push.enable";
775775+ default = true;
777776 description = ''
778777 Whether to configure Nextcloud to use the recommended Redis settings for small instances.
778778+779779+ ::: {.note}
780780+ The Nextcloud system check recommends to configure either Redis or Memcache for file lock caching.
781781+ :::
779782780783 ::: {.note}
781784 The `notify_push` app requires Redis to be configured. If this option is turned off, this must be configured manually.
···11+# shellcheck shell=bash
22+33+dotnetConfigurePhase() {
44+ echo "Executing dotnetConfigureHook"
55+66+ runHook preConfigure
77+88+ local -a projectFiles flags runtimeIds
99+ concatTo projectFiles dotnetProjectFiles dotnetTestProjectFiles
1010+ concatTo flags dotnetFlags dotnetRestoreFlags
1111+ concatTo runtimeIds dotnetRuntimeIds
1212+1313+ if [[ -z ${enableParallelBuilding-} ]]; then
1414+ flags+=(--disable-parallel)
1515+ fi
1616+1717+ if [[ -v dotnetSelfContainedBuild ]]; then
1818+ if [[ -n $dotnetSelfContainedBuild ]]; then
1919+ flags+=("-p:SelfContained=true")
2020+ else
2121+ flags+=("-p:SelfContained=false")
2222+ fi
2323+ fi
2424+2525+ dotnetRestore() {
2626+ local -r projectFile="${1-}"
2727+ for runtimeId in "${runtimeIds[@]}"; do
2828+ dotnet restore ${1+"$projectFile"} \
2929+ -p:ContinuousIntegrationBuild=true \
3030+ -p:Deterministic=true \
3131+ -p:NuGetAudit=false \
3232+ --runtime "$runtimeId" \
3333+ "${flags[@]}"
3434+ done
3535+ }
3636+3737+ if [[ -f .config/dotnet-tools.json || -f dotnet-tools.json ]]; then
3838+ dotnet tool restore
3939+ fi
4040+4141+ # dotnetGlobalTool is set in buildDotnetGlobalTool to patch dependencies but
4242+ # avoid other project-specific logic. This is a hack, but the old behavior
4343+ # is worse as it relied on a bug: setting projectFile to an empty string
4444+ # made the hooks actually skip all project-specific logic. It’s hard to keep
4545+ # backwards compatibility with this odd behavior now since we are using
4646+ # arrays, so instead we just pass a variable to indicate that we don’t have
4747+ # projects.
4848+ if [[ -z ${dotnetGlobalTool-} ]]; then
4949+ if (( ${#projectFiles[@]} == 0 )); then
5050+ dotnetRestore
5151+ fi
5252+5353+ local projectFile
5454+ for projectFile in "${projectFiles[@]}"; do
5555+ dotnetRestore "$projectFile"
5656+ done
5757+ fi
5858+5959+ runHook postConfigure
6060+6161+ echo "Finished dotnetConfigureHook"
6262+}
6363+6464+if [[ -z "${dontDotnetConfigure-}" && -z "${configurePhase-}" ]]; then
6565+ configurePhase=dotnetConfigurePhase
6666+fi
6767+6868+dotnetBuildPhase() {
6969+ echo "Executing dotnetBuildHook"
7070+7171+ runHook preBuild
7272+7373+ local -r dotnetBuildType="${dotnetBuildType-Release}"
7474+7575+ local -a projectFiles flags runtimeIds
7676+ concatTo projectFiles dotnetProjectFiles dotnetTestProjectFiles
7777+ concatTo flags dotnetFlags dotnetBuildFlags
7878+ concatTo runtimeIds dotnetRuntimeIds
7979+8080+ if [[ -n "${enableParallelBuilding-}" ]]; then
8181+ local -r maxCpuFlag="$NIX_BUILD_CORES"
8282+ local -r parallelBuildFlag="true"
8383+ else
8484+ local -r maxCpuFlag="1"
8585+ local -r parallelBuildFlag="false"
8686+ fi
8787+8888+ if [[ -v dotnetSelfContainedBuild ]]; then
8989+ if [[ -n $dotnetSelfContainedBuild ]]; then
9090+ flags+=("-p:SelfContained=true")
9191+ else
9292+ flags+=("-p:SelfContained=false")
9393+ fi
9494+ fi
9595+9696+ if [[ -n ${dotnetUseAppHost-} ]]; then
9797+ flags+=("-p:UseAppHost=true")
9898+ fi
9999+100100+ if [[ -n ${version-} ]]; then
101101+ flags+=("-p:InformationalVersion=$version")
102102+ fi
103103+104104+ if [[ -n ${versionForDotnet-} ]]; then
105105+ flags+=("-p:Version=$versionForDotnet")
106106+ fi
107107+108108+ dotnetBuild() {
109109+ local -r projectFile="${1-}"
110110+111111+ for runtimeId in "${runtimeIds[@]}"; do
112112+ local runtimeIdFlags=()
113113+ if [[ $projectFile == *.csproj || -n ${dotnetSelfContainedBuild-} ]]; then
114114+ runtimeIdFlags+=("--runtime" "$runtimeId")
115115+ fi
116116+117117+ dotnet build ${1+"$projectFile"} \
118118+ -maxcpucount:"$maxCpuFlag" \
119119+ -p:BuildInParallel="$parallelBuildFlag" \
120120+ -p:ContinuousIntegrationBuild=true \
121121+ -p:Deterministic=true \
122122+ -p:OverwriteReadOnlyFiles=true \
123123+ --configuration "$dotnetBuildType" \
124124+ --no-restore \
125125+ "${runtimeIdFlags[@]}" \
126126+ "${flags[@]}"
127127+ done
128128+ }
129129+130130+ if (( ${#projectFiles[@]} == 0 )); then
131131+ dotnetBuild
132132+ fi
133133+134134+ local projectFile
135135+ for projectFile in "${projectFiles[@]}"; do
136136+ dotnetBuild "$projectFile"
137137+ done
138138+139139+ runHook postBuild
140140+141141+ echo "Finished dotnetBuildHook"
142142+}
143143+144144+if [[ -z ${dontDotnetBuild-} && -z ${buildPhase-} ]]; then
145145+ buildPhase=dotnetBuildPhase
146146+fi
147147+148148+dotnetCheckPhase() {
149149+ echo "Executing dotnetCheckHook"
150150+151151+ runHook preCheck
152152+153153+ local -r dotnetBuildType="${dotnetBuildType-Release}"
154154+155155+ local -a projectFiles testProjectFiles testFilters disabledTests flags runtimeIds runtimeDeps
156156+ concatTo projectFiles dotnetProjectFiles
157157+ concatTo testProjectFiles dotnetTestProjectFiles
158158+ concatTo testFilters dotnetTestFilters
159159+ concatTo disabledTests dotnetDisabledTests
160160+ concatTo flags dotnetFlags dotnetTestFlags
161161+ concatTo runtimeIds dotnetRuntimeIds
162162+ concatTo runtimeDeps dotnetRuntimeDeps
163163+164164+ if (( ${#disabledTests[@]} > 0 )); then
165165+ local disabledTestsFilters=("${disabledTests[@]/#/FullyQualifiedName!=}")
166166+ testFilters=( "${testFilters[@]}" "${disabledTestsFilters[@]//,/%2C}" )
167167+ fi
168168+169169+ if (( ${#testFilters[@]} > 0 )); then
170170+ local OLDIFS="$IFS" IFS='&'
171171+ flags+=("--filter:${testFilters[*]}")
172172+ IFS="$OLDIFS"
173173+ fi
174174+175175+ local libraryPath="${LD_LIBRARY_PATH-}"
176176+ if (( ${#runtimeDeps[@]} > 0 )); then
177177+ local libraryPaths=("${runtimeDeps[@]/%//lib}")
178178+ local OLDIFS="$IFS" IFS=':'
179179+ libraryPath="${libraryPaths[*]}${libraryPath:+':'}$libraryPath"
180180+ IFS="$OLDIFS"
181181+ fi
182182+183183+ if [[ -n ${enableParallelBuilding-} ]]; then
184184+ local -r maxCpuFlag="$NIX_BUILD_CORES"
185185+ else
186186+ local -r maxCpuFlag="1"
187187+ fi
188188+189189+ local projectFile runtimeId
190190+ for projectFile in "${testProjectFiles[@]-${projectFiles[@]}}"; do
191191+ for runtimeId in "${runtimeIds[@]}"; do
192192+ local runtimeIdFlags=()
193193+ if [[ $projectFile == *.csproj ]]; then
194194+ runtimeIdFlags=("--runtime" "$runtimeId")
195195+ fi
196196+197197+ LD_LIBRARY_PATH=$libraryPath \
198198+ dotnet test "$projectFile" \
199199+ -maxcpucount:"$maxCpuFlag" \
200200+ -p:ContinuousIntegrationBuild=true \
201201+ -p:Deterministic=true \
202202+ --configuration "$dotnetBuildType" \
203203+ --no-restore \
204204+ --no-build \
205205+ --logger "console;verbosity=normal" \
206206+ "${runtimeIdFlags[@]}" \
207207+ "${flags[@]}"
208208+ done
209209+ done
210210+211211+ runHook postCheck
212212+213213+ echo "Finished dotnetCheckHook"
214214+}
215215+216216+if [[ -z "${dontDotnetCheck-}" && -z "${checkPhase-}" ]]; then
217217+ checkPhase=dotnetCheckPhase
218218+fi
219219+220220+# For compatibility, convert makeWrapperArgs to an array unless we are using
221221+# structured attributes. That is, we ensure that makeWrapperArgs is always an
222222+# array.
223223+# See https://github.com/NixOS/nixpkgs/blob/858f4db3048c5be3527e183470e93c1a72c5727c/pkgs/build-support/dotnet/build-dotnet-module/hooks/dotnet-fixup-hook.sh#L1-L3
224224+# and https://github.com/NixOS/nixpkgs/pull/313005#issuecomment-2175482920
225225+# shellcheck disable=2206
226226+if [[ -z $__structuredAttrs ]]; then
227227+ makeWrapperArgs=( ${makeWrapperArgs-} )
228228+fi
229229+230230+# First argument is the executable you want to wrap,
231231+# the second is the destination for the wrapper.
232232+wrapDotnetProgram() {
233233+ local -r dotnetRuntime=@dotnetRuntime@
234234+ local -r wrapperPath=@wrapperPath@
235235+236236+ # shellcheck disable=2016
237237+ local -r dotnetFromEnvScript='dotnetFromEnv() {
238238+ local dotnetPath
239239+ if command -v dotnet 2>&1 >/dev/null; then
240240+ dotnetPath=$(which dotnet) && \
241241+ dotnetPath=$(realpath "$dotnetPath") && \
242242+ dotnetPath=$(dirname "$dotnetPath") && \
243243+ export DOTNET_ROOT="$dotnetPath"
244244+ fi
245245+}
246246+dotnetFromEnv'
247247+248248+ # shellcheck disable=2206
249249+ local -a runtimeDeps
250250+ concatTo runtimeDeps dotnetRuntimeDeps
251251+252252+ local wrapperFlags=()
253253+ if (( ${#runtimeDeps[@]} > 0 )); then
254254+ local libraryPath=("${dotnetRuntimeDeps[@]/%//lib}")
255255+ local OLDIFS="$IFS" IFS=':'
256256+ wrapperFlags+=("--suffix" "LD_LIBRARY_PATH" ":" "${libraryPath[*]}")
257257+ IFS="$OLDIFS"
258258+ fi
259259+260260+ if [[ -z ${dotnetSelfContainedBuild-} ]]; then
261261+ if [[ -n ${useDotnetFromEnv-} ]]; then
262262+ # if dotnet CLI is available, set DOTNET_ROOT based on it. Otherwise set to default .NET runtime
263263+ wrapperFlags+=("--suffix" "PATH" ":" "$wrapperPath")
264264+ wrapperFlags+=("--run" "$dotnetFromEnvScript")
265265+ if [[ -n $dotnetRuntime ]]; then
266266+ wrapperFlags+=("--set-default" "DOTNET_ROOT" "$dotnetRuntime/share/dotnet")
267267+ wrapperFlags+=("--suffix" "PATH" ":" "$dotnetRuntime/bin")
268268+ fi
269269+ elif [[ -n $dotnetRuntime ]]; then
270270+ wrapperFlags+=("--set" "DOTNET_ROOT" "$dotnetRuntime/share/dotnet")
271271+ wrapperFlags+=("--prefix" "PATH" ":" "$dotnetRuntime/bin")
272272+ fi
273273+ fi
274274+275275+ # shellcheck disable=2154
276276+ makeWrapper "$1" "$2" \
277277+ "${wrapperFlags[@]}" \
278278+ "${gappsWrapperArgs[@]}" \
279279+ "${makeWrapperArgs[@]}"
280280+281281+ echo "installed wrapper to $2"
282282+}
283283+284284+dotnetFixupPhase() {
285285+ local -r dotnetInstallPath="${dotnetInstallPath-$out/lib/$pname}"
286286+287287+ local executable executableBasename
288288+289289+ # check if dotnetExecutables is declared (including empty values, in which case we generate no executables)
290290+ # shellcheck disable=2154
291291+ if declare -p dotnetExecutables &>/dev/null; then
292292+ # shellcheck disable=2206
293293+ local -a executables
294294+ concatTo executables dotnetExecutables
295295+ for executable in "${executables[@]}"; do
296296+ executableBasename=$(basename "$executable")
297297+298298+ local path="$dotnetInstallPath/$executable"
299299+300300+ if test -x "$path"; then
301301+ wrapDotnetProgram "$path" "$out/bin/$executableBasename"
302302+ else
303303+ echo "Specified binary \"$executable\" is either not an executable or does not exist!"
304304+ echo "Looked in $path"
305305+ exit 1
306306+ fi
307307+ done
308308+ else
309309+ while IFS= read -r -d '' executable; do
310310+ executableBasename=$(basename "$executable")
311311+ wrapDotnetProgram "$executable" "$out/bin/$executableBasename" \;
312312+ done < <(find "$dotnetInstallPath" ! -name "*.dll" -executable -type f -print0)
313313+ fi
314314+}
315315+316316+if [[ -z "${dontFixup-}" && -z "${dontDotnetFixup-}" ]]; then
317317+ appendToVar preFixupPhases dotnetFixupPhase
318318+fi
319319+320320+dotnetInstallPhase() {
321321+ echo "Executing dotnetInstallHook"
322322+323323+ runHook preInstall
324324+325325+ local -r dotnetInstallPath="${dotnetInstallPath-$out/lib/$pname}"
326326+ local -r dotnetBuildType="${dotnetBuildType-Release}"
327327+328328+ local -a projectFiles flags installFlags packFlags runtimeIds
329329+ concatTo projectFiles dotnetProjectFiles
330330+ concatTo flags dotnetFlags
331331+ concatTo installFlags dotnetInstallFlags
332332+ concatTo packFlags dotnetPackFlags
333333+ concatTo runtimeIds dotnetRuntimeIds
334334+335335+ if [[ -v dotnetSelfContainedBuild ]]; then
336336+ if [[ -n $dotnetSelfContainedBuild ]]; then
337337+ installFlags+=("--self-contained")
338338+ else
339339+ installFlags+=("--no-self-contained")
340340+ # https://learn.microsoft.com/en-us/dotnet/core/deploying/trimming/trim-self-contained
341341+ # Trimming is only available for self-contained build, so force disable it here
342342+ installFlags+=("-p:PublishTrimmed=false")
343343+ fi
344344+ fi
345345+346346+ if [[ -n ${dotnetUseAppHost-} ]]; then
347347+ installFlags+=("-p:UseAppHost=true")
348348+ fi
349349+350350+ if [[ -n ${enableParallelBuilding-} ]]; then
351351+ local -r maxCpuFlag="$NIX_BUILD_CORES"
352352+ else
353353+ local -r maxCpuFlag="1"
354354+ fi
355355+356356+ dotnetPublish() {
357357+ local -r projectFile="${1-}"
358358+359359+ for runtimeId in "${runtimeIds[@]}"; do
360360+ runtimeIdFlags=()
361361+ if [[ $projectFile == *.csproj || -n ${dotnetSelfContainedBuild-} ]]; then
362362+ runtimeIdFlags+=("--runtime" "$runtimeId")
363363+ fi
364364+365365+ dotnet publish ${1+"$projectFile"} \
366366+ -maxcpucount:"$maxCpuFlag" \
367367+ -p:ContinuousIntegrationBuild=true \
368368+ -p:Deterministic=true \
369369+ -p:OverwriteReadOnlyFiles=true \
370370+ --output "$dotnetInstallPath" \
371371+ --configuration "$dotnetBuildType" \
372372+ --no-restore \
373373+ --no-build \
374374+ "${runtimeIdFlags[@]}" \
375375+ "${flags[@]}" \
376376+ "${installFlags[@]}"
377377+ done
378378+ }
379379+380380+ dotnetPack() {
381381+ local -r projectFile="${1-}"
382382+383383+ for runtimeId in "${runtimeIds[@]}"; do
384384+ dotnet pack ${1+"$projectFile"} \
385385+ -maxcpucount:"$maxCpuFlag" \
386386+ -p:ContinuousIntegrationBuild=true \
387387+ -p:Deterministic=true \
388388+ -p:OverwriteReadOnlyFiles=true \
389389+ --output "$out/share/nuget/source" \
390390+ --configuration "$dotnetBuildType" \
391391+ --no-restore \
392392+ --no-build \
393393+ --runtime "$runtimeId" \
394394+ "${flags[@]}" \
395395+ "${packFlags[@]}"
396396+ done
397397+ }
398398+399399+ if (( ${#projectFiles[@]} == 0 )); then
400400+ dotnetPublish
401401+ else
402402+ local projectFile
403403+ for projectFile in "${projectFiles[@]}"; do
404404+ dotnetPublish "$projectFile"
405405+ done
406406+ fi
407407+408408+ if [[ -n ${packNupkg-} ]]; then
409409+ if (( ${#projectFiles[@]} == 0 )); then
410410+ dotnetPack
411411+ else
412412+ local projectFile
413413+ for projectFile in "${projectFiles[@]}"; do
414414+ dotnetPack "$projectFile"
415415+ done
416416+ fi
417417+ fi
418418+419419+ runHook postInstall
420420+421421+ echo "Finished dotnetInstallHook"
422422+}
423423+424424+if [[ -z "${dontDotnetInstall-}" && -z "${installPhase-}" ]]; then
425425+ installPhase=dotnetInstallPhase
426426+fi
···11-dotnetConfigureHook() {
22- echo "Executing dotnetConfigureHook"
33-44- runHook preConfigure
55-66- local -r dynamicLinker=@dynamicLinker@
77- local -r libPath=@libPath@
88-99- if [[ -n $__structuredAttrs ]]; then
1010- local dotnetProjectFilesArray=( "${dotnetProjectFiles[@]}" )
1111- local dotnetTestProjectFilesArray=( "${dotnetTestProjectFiles[@]}" )
1212- local dotnetFlagsArray=( "${dotnetFlags[@]}" )
1313- local dotnetRestoreFlagsArray=( "${dotnetRestoreFlags[@]}" )
1414- local dotnetRuntimeIdsArray=( "${dotnetRuntimeIds[@]}" )
1515- else
1616- local dotnetProjectFilesArray=($dotnetProjectFiles)
1717- local dotnetTestProjectFilesArray=($dotnetTestProjectFiles)
1818- local dotnetFlagsArray=($dotnetFlags)
1919- local dotnetRestoreFlagsArray=($dotnetRestoreFlags)
2020- local dotnetRuntimeIdsArray=($dotnetRuntimeIds)
2121- fi
2222-2323- if [[ -z ${enableParallelBuilding-} ]]; then
2424- local -r parallelFlag="--disable-parallel"
2525- fi
2626-2727- if [[ -v dotnetSelfContainedBuild ]]; then
2828- if [[ -n $dotnetSelfContainedBuild ]]; then
2929- dotnetRestoreFlagsArray+=("-p:SelfContained=true")
3030- else
3131- dotnetRestoreFlagsArray+=("-p:SelfContained=false")
3232- fi
3333- fi
3434-3535- dotnetRestore() {
3636- local -r projectFile="${1-}"
3737- for runtimeId in "${dotnetRuntimeIdsArray[@]}"; do
3838- dotnet restore ${1+"$projectFile"} \
3939- -p:ContinuousIntegrationBuild=true \
4040- -p:Deterministic=true \
4141- -p:NuGetAudit=false \
4242- --runtime "$runtimeId" \
4343- ${parallelFlag-} \
4444- "${dotnetRestoreFlagsArray[@]}" \
4545- "${dotnetFlagsArray[@]}"
4646- done
4747- }
4848-4949- if [[ -f .config/dotnet-tools.json || -f dotnet-tools.json ]]; then
5050- dotnet tool restore
5151- fi
5252-5353- # dotnetGlobalTool is set in buildDotnetGlobalTool to patch dependencies but
5454- # avoid other project-specific logic. This is a hack, but the old behavior
5555- # is worse as it relied on a bug: setting projectFile to an empty string
5656- # made the hooks actually skip all project-specific logic. It’s hard to keep
5757- # backwards compatibility with this odd behavior now since we are using
5858- # arrays, so instead we just pass a variable to indicate that we don’t have
5959- # projects.
6060- if [[ -z ${dotnetGlobalTool-} ]]; then
6161- if (( ${#dotnetProjectFilesArray[@]} == 0 )); then
6262- dotnetRestore
6363- fi
6464-6565- local projectFile
6666- for projectFile in "${dotnetProjectFilesArray[@]}" "${dotnetTestProjectFilesArray[@]}"; do
6767- dotnetRestore "$projectFile"
6868- done
6969- fi
7070-7171- runHook postConfigure
7272-7373- echo "Finished dotnetConfigureHook"
7474-}
7575-7676-if [[ -z "${dontDotnetConfigure-}" && -z "${configurePhase-}" ]]; then
7777- configurePhase=dotnetConfigureHook
7878-fi
···11-# For compatibility, convert makeWrapperArgs to an array unless we are using
22-# structured attributes. That is, we ensure that makeWrapperArgs is always an
33-# array.
44-# See https://github.com/NixOS/nixpkgs/blob/858f4db3048c5be3527e183470e93c1a72c5727c/pkgs/build-support/dotnet/build-dotnet-module/hooks/dotnet-fixup-hook.sh#L1-L3
55-# and https://github.com/NixOS/nixpkgs/pull/313005#issuecomment-2175482920
66-if [[ -z $__structuredAttrs ]]; then
77- makeWrapperArgs=( ${makeWrapperArgs-} )
88-fi
99-1010-# First argument is the executable you want to wrap,
1111-# the second is the destination for the wrapper.
1212-wrapDotnetProgram() {
1313- local -r dotnetRuntime=@dotnetRuntime@
1414- local -r wrapperPath=@wrapperPath@
1515-1616- local -r dotnetFromEnvScript='dotnetFromEnv() {
1717- local dotnetPath
1818- if command -v dotnet 2>&1 >/dev/null; then
1919- dotnetPath=$(which dotnet) && \
2020- dotnetPath=$(realpath "$dotnetPath") && \
2121- dotnetPath=$(dirname "$dotnetPath") && \
2222- export DOTNET_ROOT="$dotnetPath"
2323- fi
2424-}
2525-dotnetFromEnv'
2626-2727- if [[ -n $__structuredAttrs ]]; then
2828- local -r dotnetRuntimeDepsArray=( "${dotnetRuntimeDeps[@]}" )
2929- else
3030- local -r dotnetRuntimeDepsArray=($dotnetRuntimeDeps)
3131- fi
3232-3333- local dotnetRuntimeDepsFlags=()
3434- if (( ${#dotnetRuntimeDepsArray[@]} > 0 )); then
3535- local libraryPathArray=("${dotnetRuntimeDepsArray[@]/%//lib}")
3636- local OLDIFS="$IFS" IFS=':'
3737- dotnetRuntimeDepsFlags+=("--suffix" "LD_LIBRARY_PATH" ":" "${libraryPathArray[*]}")
3838- IFS="$OLDIFS"
3939- fi
4040-4141- local dotnetRootFlagsArray=()
4242- if [[ -z ${dotnetSelfContainedBuild-} ]]; then
4343- if [[ -n ${useDotnetFromEnv-} ]]; then
4444- # if dotnet CLI is available, set DOTNET_ROOT based on it. Otherwise set to default .NET runtime
4545- dotnetRootFlagsArray+=("--suffix" "PATH" ":" "$wrapperPath")
4646- dotnetRootFlagsArray+=("--run" "$dotnetFromEnvScript")
4747- if [[ -n $dotnetRuntime ]]; then
4848- dotnetRootFlagsArray+=("--set-default" "DOTNET_ROOT" "$dotnetRuntime/share/dotnet")
4949- dotnetRootFlagsArray+=("--suffix" "PATH" ":" "$dotnetRuntime/bin")
5050- fi
5151- elif [[ -n $dotnetRuntime ]]; then
5252- dotnetRootFlagsArray+=("--set" "DOTNET_ROOT" "$dotnetRuntime/share/dotnet")
5353- dotnetRootFlagsArray+=("--prefix" "PATH" ":" "$dotnetRuntime/bin")
5454- fi
5555- fi
5656-5757- makeWrapper "$1" "$2" \
5858- "${dotnetRuntimeDepsFlags[@]}" \
5959- "${dotnetRootFlagsArray[@]}" \
6060- "${gappsWrapperArgs[@]}" \
6161- "${makeWrapperArgs[@]}"
6262-6363- echo "installed wrapper to "$2""
6464-}
6565-6666-dotnetFixupHook() {
6767- local -r dotnetInstallPath="${dotnetInstallPath-$out/lib/$pname}"
6868-6969- local executable executableBasename
7070-7171- # check if dotnetExecutables is declared (including empty values, in which case we generate no executables)
7272- if declare -p dotnetExecutables &>/dev/null; then
7373- if [[ -n $__structuredAttrs ]]; then
7474- local dotnetExecutablesArray=( "${dotnetExecutables[@]}" )
7575- else
7676- local dotnetExecutablesArray=($dotnetExecutables)
7777- fi
7878- for executable in "${dotnetExecutablesArray[@]}"; do
7979- executableBasename=$(basename "$executable")
8080-8181- local path="$dotnetInstallPath/$executable"
8282-8383- if test -x "$path"; then
8484- wrapDotnetProgram "$path" "$out/bin/$executableBasename"
8585- else
8686- echo "Specified binary \"$executable\" is either not an executable or does not exist!"
8787- echo "Looked in $path"
8888- exit 1
8989- fi
9090- done
9191- else
9292- while IFS= read -d '' executable; do
9393- executableBasename=$(basename "$executable")
9494- wrapDotnetProgram "$executable" "$out/bin/$executableBasename" \;
9595- done < <(find "$dotnetInstallPath" ! -name "*.dll" -executable -type f -print0)
9696- fi
9797-}
9898-9999-if [[ -z "${dontFixup-}" && -z "${dontDotnetFixup-}" ]]; then
100100- appendToVar preFixupPhases dotnetFixupHook
101101-fi
···6464 postPatch = ''
6565 chmod +x install-scripts/meson_install_schemas.py # patchShebangs requires executable file
6666 patchShebangs install-scripts/meson_install_schemas.py
6767- sed "s|/usr/share|/run/current-system/sw/share|g" -i ./schemas/* # NOTE: unless this causes a circular dependency, we could link it to cinnamon-common/share/cinnamon
6767+ sed "s|/usr/share|/run/current-system/sw/share|g" -i ./schemas/* # NOTE: unless this causes a circular dependency, we could link it to cinnamon/share/cinnamon
6868 '';
69697070 meta = with lib; {
···4242# as bootloader for various platforms and corresponding binary and helper files.
4343stdenv.mkDerivation (finalAttrs: {
4444 pname = "limine";
4545- version = "9.5.1";
4545+ version = "9.5.4";
46464747 # We don't use the Git source but the release tarball, as the source has a
4848 # `./bootstrap` script performing network access to download resources.
4949 # Packaging that in Nix is very cumbersome.
5050 src = fetchurl {
5151 url = "https://github.com/limine-bootloader/limine/releases/download/v${finalAttrs.version}/limine-${finalAttrs.version}.tar.gz";
5252- hash = "sha256-UgY8S+XGlSnO1k98JWBfSN0/IY3LANVFgJwI1kdPAcU=";
5252+ hash = "sha256-X0dStbsBJyFDUG25G4PUZInp+yVG3+p3bfhwQL280ig=";
5353 };
54545555 enableParallelBuilding = true;
···446446 CHOWTapeModel = chow-tape-model; # Added 2024-06-12
447447 chromatic = throw "chromatic has been removed due to being unmaintained and failing to build"; # Added 2025-04-18
448448 chrome-gnome-shell = gnome-browser-connector; # Added 2022-07-27
449449- cinnamon = throw "The cinnamon scope has been removed and all packages have been moved to the top-level"; # Added 2024-11-25
449449+ cinnamon-common = cinnamon; # Added 2025-08-06
450450 citra = throw "citra has been removed from nixpkgs, as it has been taken down upstream"; # added 2024-03-04
451451 citra-nightly = throw "citra-nightly has been removed from nixpkgs, as it has been taken down upstream"; # added 2024-03-04
452452 citra-canary = throw "citra-canary has been removed from nixpkgs, as it has been taken down upstream"; # added 2024-03-04