···161162- `services.dnscrypt-proxy2` gains a `package` option to specify dnscrypt-proxy package to use.
16300164- `services.gitea` supports sending notifications with sendmail again. To do this, activate the parameter `services.gitea.mailerUseSendmail` and configure SMTP server.
165166- `libvirt` now supports using `nftables` backend.
···161162- `services.dnscrypt-proxy2` gains a `package` option to specify dnscrypt-proxy package to use.
163164+- `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.
165+166- `services.gitea` supports sending notifications with sendmail again. To do this, activate the parameter `services.gitea.mailerUseSendmail` and configure SMTP server.
167168- `libvirt` now supports using `nftables` backend.
···772773 configureRedis = lib.mkOption {
774 type = lib.types.bool;
775- default = config.services.nextcloud.notify_push.enable;
776- defaultText = lib.literalExpression "config.services.nextcloud.notify_push.enable";
777 description = ''
778 Whether to configure Nextcloud to use the recommended Redis settings for small instances.
0000779780 ::: {.note}
781 The `notify_push` app requires Redis to be configured. If this option is turned off, this must be configured manually.
···772773 configureRedis = lib.mkOption {
774 type = lib.types.bool;
775+ default = true;
0776 description = ''
777 Whether to configure Nextcloud to use the recommended Redis settings for small instances.
778+779+ ::: {.note}
780+ The Nextcloud system check recommends to configure either Redis or Memcache for file lock caching.
781+ :::
782783 ::: {.note}
784 The `notify_push` app requires Redis to be configured. If this option is turned off, this must be configured manually.
···1+# shellcheck shell=bash
2+3+dotnetConfigurePhase() {
4+ echo "Executing dotnetConfigureHook"
5+6+ runHook preConfigure
7+8+ local -a projectFiles flags runtimeIds
9+ concatTo projectFiles dotnetProjectFiles dotnetTestProjectFiles
10+ concatTo flags dotnetFlags dotnetRestoreFlags
11+ concatTo runtimeIds dotnetRuntimeIds
12+13+ if [[ -z ${enableParallelBuilding-} ]]; then
14+ flags+=(--disable-parallel)
15+ fi
16+17+ if [[ -v dotnetSelfContainedBuild ]]; then
18+ if [[ -n $dotnetSelfContainedBuild ]]; then
19+ flags+=("-p:SelfContained=true")
20+ else
21+ flags+=("-p:SelfContained=false")
22+ fi
23+ fi
24+25+ dotnetRestore() {
26+ local -r projectFile="${1-}"
27+ for runtimeId in "${runtimeIds[@]}"; do
28+ dotnet restore ${1+"$projectFile"} \
29+ -p:ContinuousIntegrationBuild=true \
30+ -p:Deterministic=true \
31+ -p:NuGetAudit=false \
32+ --runtime "$runtimeId" \
33+ "${flags[@]}"
34+ done
35+ }
36+37+ if [[ -f .config/dotnet-tools.json || -f dotnet-tools.json ]]; then
38+ dotnet tool restore
39+ fi
40+41+ # dotnetGlobalTool is set in buildDotnetGlobalTool to patch dependencies but
42+ # avoid other project-specific logic. This is a hack, but the old behavior
43+ # is worse as it relied on a bug: setting projectFile to an empty string
44+ # made the hooks actually skip all project-specific logic. It’s hard to keep
45+ # backwards compatibility with this odd behavior now since we are using
46+ # arrays, so instead we just pass a variable to indicate that we don’t have
47+ # projects.
48+ if [[ -z ${dotnetGlobalTool-} ]]; then
49+ if (( ${#projectFiles[@]} == 0 )); then
50+ dotnetRestore
51+ fi
52+53+ local projectFile
54+ for projectFile in "${projectFiles[@]}"; do
55+ dotnetRestore "$projectFile"
56+ done
57+ fi
58+59+ runHook postConfigure
60+61+ echo "Finished dotnetConfigureHook"
62+}
63+64+if [[ -z "${dontDotnetConfigure-}" && -z "${configurePhase-}" ]]; then
65+ configurePhase=dotnetConfigurePhase
66+fi
67+68+dotnetBuildPhase() {
69+ echo "Executing dotnetBuildHook"
70+71+ runHook preBuild
72+73+ local -r dotnetBuildType="${dotnetBuildType-Release}"
74+75+ local -a projectFiles flags runtimeIds
76+ concatTo projectFiles dotnetProjectFiles dotnetTestProjectFiles
77+ concatTo flags dotnetFlags dotnetBuildFlags
78+ concatTo runtimeIds dotnetRuntimeIds
79+80+ if [[ -n "${enableParallelBuilding-}" ]]; then
81+ local -r maxCpuFlag="$NIX_BUILD_CORES"
82+ local -r parallelBuildFlag="true"
83+ else
84+ local -r maxCpuFlag="1"
85+ local -r parallelBuildFlag="false"
86+ fi
87+88+ if [[ -v dotnetSelfContainedBuild ]]; then
89+ if [[ -n $dotnetSelfContainedBuild ]]; then
90+ flags+=("-p:SelfContained=true")
91+ else
92+ flags+=("-p:SelfContained=false")
93+ fi
94+ fi
95+96+ if [[ -n ${dotnetUseAppHost-} ]]; then
97+ flags+=("-p:UseAppHost=true")
98+ fi
99+100+ if [[ -n ${version-} ]]; then
101+ flags+=("-p:InformationalVersion=$version")
102+ fi
103+104+ if [[ -n ${versionForDotnet-} ]]; then
105+ flags+=("-p:Version=$versionForDotnet")
106+ fi
107+108+ dotnetBuild() {
109+ local -r projectFile="${1-}"
110+111+ for runtimeId in "${runtimeIds[@]}"; do
112+ local runtimeIdFlags=()
113+ if [[ $projectFile == *.csproj || -n ${dotnetSelfContainedBuild-} ]]; then
114+ runtimeIdFlags+=("--runtime" "$runtimeId")
115+ fi
116+117+ dotnet build ${1+"$projectFile"} \
118+ -maxcpucount:"$maxCpuFlag" \
119+ -p:BuildInParallel="$parallelBuildFlag" \
120+ -p:ContinuousIntegrationBuild=true \
121+ -p:Deterministic=true \
122+ -p:OverwriteReadOnlyFiles=true \
123+ --configuration "$dotnetBuildType" \
124+ --no-restore \
125+ "${runtimeIdFlags[@]}" \
126+ "${flags[@]}"
127+ done
128+ }
129+130+ if (( ${#projectFiles[@]} == 0 )); then
131+ dotnetBuild
132+ fi
133+134+ local projectFile
135+ for projectFile in "${projectFiles[@]}"; do
136+ dotnetBuild "$projectFile"
137+ done
138+139+ runHook postBuild
140+141+ echo "Finished dotnetBuildHook"
142+}
143+144+if [[ -z ${dontDotnetBuild-} && -z ${buildPhase-} ]]; then
145+ buildPhase=dotnetBuildPhase
146+fi
147+148+dotnetCheckPhase() {
149+ echo "Executing dotnetCheckHook"
150+151+ runHook preCheck
152+153+ local -r dotnetBuildType="${dotnetBuildType-Release}"
154+155+ local -a projectFiles testProjectFiles testFilters disabledTests flags runtimeIds runtimeDeps
156+ concatTo projectFiles dotnetProjectFiles
157+ concatTo testProjectFiles dotnetTestProjectFiles
158+ concatTo testFilters dotnetTestFilters
159+ concatTo disabledTests dotnetDisabledTests
160+ concatTo flags dotnetFlags dotnetTestFlags
161+ concatTo runtimeIds dotnetRuntimeIds
162+ concatTo runtimeDeps dotnetRuntimeDeps
163+164+ if (( ${#disabledTests[@]} > 0 )); then
165+ local disabledTestsFilters=("${disabledTests[@]/#/FullyQualifiedName!=}")
166+ testFilters=( "${testFilters[@]}" "${disabledTestsFilters[@]//,/%2C}" )
167+ fi
168+169+ if (( ${#testFilters[@]} > 0 )); then
170+ local OLDIFS="$IFS" IFS='&'
171+ flags+=("--filter:${testFilters[*]}")
172+ IFS="$OLDIFS"
173+ fi
174+175+ local libraryPath="${LD_LIBRARY_PATH-}"
176+ if (( ${#runtimeDeps[@]} > 0 )); then
177+ local libraryPaths=("${runtimeDeps[@]/%//lib}")
178+ local OLDIFS="$IFS" IFS=':'
179+ libraryPath="${libraryPaths[*]}${libraryPath:+':'}$libraryPath"
180+ IFS="$OLDIFS"
181+ fi
182+183+ if [[ -n ${enableParallelBuilding-} ]]; then
184+ local -r maxCpuFlag="$NIX_BUILD_CORES"
185+ else
186+ local -r maxCpuFlag="1"
187+ fi
188+189+ local projectFile runtimeId
190+ for projectFile in "${testProjectFiles[@]-${projectFiles[@]}}"; do
191+ for runtimeId in "${runtimeIds[@]}"; do
192+ local runtimeIdFlags=()
193+ if [[ $projectFile == *.csproj ]]; then
194+ runtimeIdFlags=("--runtime" "$runtimeId")
195+ fi
196+197+ LD_LIBRARY_PATH=$libraryPath \
198+ dotnet test "$projectFile" \
199+ -maxcpucount:"$maxCpuFlag" \
200+ -p:ContinuousIntegrationBuild=true \
201+ -p:Deterministic=true \
202+ --configuration "$dotnetBuildType" \
203+ --no-restore \
204+ --no-build \
205+ --logger "console;verbosity=normal" \
206+ "${runtimeIdFlags[@]}" \
207+ "${flags[@]}"
208+ done
209+ done
210+211+ runHook postCheck
212+213+ echo "Finished dotnetCheckHook"
214+}
215+216+if [[ -z "${dontDotnetCheck-}" && -z "${checkPhase-}" ]]; then
217+ checkPhase=dotnetCheckPhase
218+fi
219+220+# For compatibility, convert makeWrapperArgs to an array unless we are using
221+# structured attributes. That is, we ensure that makeWrapperArgs is always an
222+# array.
223+# See https://github.com/NixOS/nixpkgs/blob/858f4db3048c5be3527e183470e93c1a72c5727c/pkgs/build-support/dotnet/build-dotnet-module/hooks/dotnet-fixup-hook.sh#L1-L3
224+# and https://github.com/NixOS/nixpkgs/pull/313005#issuecomment-2175482920
225+# shellcheck disable=2206
226+if [[ -z $__structuredAttrs ]]; then
227+ makeWrapperArgs=( ${makeWrapperArgs-} )
228+fi
229+230+# First argument is the executable you want to wrap,
231+# the second is the destination for the wrapper.
232+wrapDotnetProgram() {
233+ local -r dotnetRuntime=@dotnetRuntime@
234+ local -r wrapperPath=@wrapperPath@
235+236+ # shellcheck disable=2016
237+ local -r dotnetFromEnvScript='dotnetFromEnv() {
238+ local dotnetPath
239+ if command -v dotnet 2>&1 >/dev/null; then
240+ dotnetPath=$(which dotnet) && \
241+ dotnetPath=$(realpath "$dotnetPath") && \
242+ dotnetPath=$(dirname "$dotnetPath") && \
243+ export DOTNET_ROOT="$dotnetPath"
244+ fi
245+}
246+dotnetFromEnv'
247+248+ # shellcheck disable=2206
249+ local -a runtimeDeps
250+ concatTo runtimeDeps dotnetRuntimeDeps
251+252+ local wrapperFlags=()
253+ if (( ${#runtimeDeps[@]} > 0 )); then
254+ local libraryPath=("${dotnetRuntimeDeps[@]/%//lib}")
255+ local OLDIFS="$IFS" IFS=':'
256+ wrapperFlags+=("--suffix" "LD_LIBRARY_PATH" ":" "${libraryPath[*]}")
257+ IFS="$OLDIFS"
258+ fi
259+260+ if [[ -z ${dotnetSelfContainedBuild-} ]]; then
261+ if [[ -n ${useDotnetFromEnv-} ]]; then
262+ # if dotnet CLI is available, set DOTNET_ROOT based on it. Otherwise set to default .NET runtime
263+ wrapperFlags+=("--suffix" "PATH" ":" "$wrapperPath")
264+ wrapperFlags+=("--run" "$dotnetFromEnvScript")
265+ if [[ -n $dotnetRuntime ]]; then
266+ wrapperFlags+=("--set-default" "DOTNET_ROOT" "$dotnetRuntime/share/dotnet")
267+ wrapperFlags+=("--suffix" "PATH" ":" "$dotnetRuntime/bin")
268+ fi
269+ elif [[ -n $dotnetRuntime ]]; then
270+ wrapperFlags+=("--set" "DOTNET_ROOT" "$dotnetRuntime/share/dotnet")
271+ wrapperFlags+=("--prefix" "PATH" ":" "$dotnetRuntime/bin")
272+ fi
273+ fi
274+275+ # shellcheck disable=2154
276+ makeWrapper "$1" "$2" \
277+ "${wrapperFlags[@]}" \
278+ "${gappsWrapperArgs[@]}" \
279+ "${makeWrapperArgs[@]}"
280+281+ echo "installed wrapper to $2"
282+}
283+284+dotnetFixupPhase() {
285+ local -r dotnetInstallPath="${dotnetInstallPath-$out/lib/$pname}"
286+287+ local executable executableBasename
288+289+ # check if dotnetExecutables is declared (including empty values, in which case we generate no executables)
290+ # shellcheck disable=2154
291+ if declare -p dotnetExecutables &>/dev/null; then
292+ # shellcheck disable=2206
293+ local -a executables
294+ concatTo executables dotnetExecutables
295+ for executable in "${executables[@]}"; do
296+ executableBasename=$(basename "$executable")
297+298+ local path="$dotnetInstallPath/$executable"
299+300+ if test -x "$path"; then
301+ wrapDotnetProgram "$path" "$out/bin/$executableBasename"
302+ else
303+ echo "Specified binary \"$executable\" is either not an executable or does not exist!"
304+ echo "Looked in $path"
305+ exit 1
306+ fi
307+ done
308+ else
309+ while IFS= read -r -d '' executable; do
310+ executableBasename=$(basename "$executable")
311+ wrapDotnetProgram "$executable" "$out/bin/$executableBasename" \;
312+ done < <(find "$dotnetInstallPath" ! -name "*.dll" -executable -type f -print0)
313+ fi
314+}
315+316+if [[ -z "${dontFixup-}" && -z "${dontDotnetFixup-}" ]]; then
317+ appendToVar preFixupPhases dotnetFixupPhase
318+fi
319+320+dotnetInstallPhase() {
321+ echo "Executing dotnetInstallHook"
322+323+ runHook preInstall
324+325+ local -r dotnetInstallPath="${dotnetInstallPath-$out/lib/$pname}"
326+ local -r dotnetBuildType="${dotnetBuildType-Release}"
327+328+ local -a projectFiles flags installFlags packFlags runtimeIds
329+ concatTo projectFiles dotnetProjectFiles
330+ concatTo flags dotnetFlags
331+ concatTo installFlags dotnetInstallFlags
332+ concatTo packFlags dotnetPackFlags
333+ concatTo runtimeIds dotnetRuntimeIds
334+335+ if [[ -v dotnetSelfContainedBuild ]]; then
336+ if [[ -n $dotnetSelfContainedBuild ]]; then
337+ installFlags+=("--self-contained")
338+ else
339+ installFlags+=("--no-self-contained")
340+ # https://learn.microsoft.com/en-us/dotnet/core/deploying/trimming/trim-self-contained
341+ # Trimming is only available for self-contained build, so force disable it here
342+ installFlags+=("-p:PublishTrimmed=false")
343+ fi
344+ fi
345+346+ if [[ -n ${dotnetUseAppHost-} ]]; then
347+ installFlags+=("-p:UseAppHost=true")
348+ fi
349+350+ if [[ -n ${enableParallelBuilding-} ]]; then
351+ local -r maxCpuFlag="$NIX_BUILD_CORES"
352+ else
353+ local -r maxCpuFlag="1"
354+ fi
355+356+ dotnetPublish() {
357+ local -r projectFile="${1-}"
358+359+ for runtimeId in "${runtimeIds[@]}"; do
360+ runtimeIdFlags=()
361+ if [[ $projectFile == *.csproj || -n ${dotnetSelfContainedBuild-} ]]; then
362+ runtimeIdFlags+=("--runtime" "$runtimeId")
363+ fi
364+365+ dotnet publish ${1+"$projectFile"} \
366+ -maxcpucount:"$maxCpuFlag" \
367+ -p:ContinuousIntegrationBuild=true \
368+ -p:Deterministic=true \
369+ -p:OverwriteReadOnlyFiles=true \
370+ --output "$dotnetInstallPath" \
371+ --configuration "$dotnetBuildType" \
372+ --no-restore \
373+ --no-build \
374+ "${runtimeIdFlags[@]}" \
375+ "${flags[@]}" \
376+ "${installFlags[@]}"
377+ done
378+ }
379+380+ dotnetPack() {
381+ local -r projectFile="${1-}"
382+383+ for runtimeId in "${runtimeIds[@]}"; do
384+ dotnet pack ${1+"$projectFile"} \
385+ -maxcpucount:"$maxCpuFlag" \
386+ -p:ContinuousIntegrationBuild=true \
387+ -p:Deterministic=true \
388+ -p:OverwriteReadOnlyFiles=true \
389+ --output "$out/share/nuget/source" \
390+ --configuration "$dotnetBuildType" \
391+ --no-restore \
392+ --no-build \
393+ --runtime "$runtimeId" \
394+ "${flags[@]}" \
395+ "${packFlags[@]}"
396+ done
397+ }
398+399+ if (( ${#projectFiles[@]} == 0 )); then
400+ dotnetPublish
401+ else
402+ local projectFile
403+ for projectFile in "${projectFiles[@]}"; do
404+ dotnetPublish "$projectFile"
405+ done
406+ fi
407+408+ if [[ -n ${packNupkg-} ]]; then
409+ if (( ${#projectFiles[@]} == 0 )); then
410+ dotnetPack
411+ else
412+ local projectFile
413+ for projectFile in "${projectFiles[@]}"; do
414+ dotnetPack "$projectFile"
415+ done
416+ fi
417+ fi
418+419+ runHook postInstall
420+421+ echo "Finished dotnetInstallHook"
422+}
423+424+if [[ -z "${dontDotnetInstall-}" && -z "${installPhase-}" ]]; then
425+ installPhase=dotnetInstallPhase
426+fi
···1-dotnetConfigureHook() {
2- echo "Executing dotnetConfigureHook"
3-4- runHook preConfigure
5-6- local -r dynamicLinker=@dynamicLinker@
7- local -r libPath=@libPath@
8-9- if [[ -n $__structuredAttrs ]]; then
10- local dotnetProjectFilesArray=( "${dotnetProjectFiles[@]}" )
11- local dotnetTestProjectFilesArray=( "${dotnetTestProjectFiles[@]}" )
12- local dotnetFlagsArray=( "${dotnetFlags[@]}" )
13- local dotnetRestoreFlagsArray=( "${dotnetRestoreFlags[@]}" )
14- local dotnetRuntimeIdsArray=( "${dotnetRuntimeIds[@]}" )
15- else
16- local dotnetProjectFilesArray=($dotnetProjectFiles)
17- local dotnetTestProjectFilesArray=($dotnetTestProjectFiles)
18- local dotnetFlagsArray=($dotnetFlags)
19- local dotnetRestoreFlagsArray=($dotnetRestoreFlags)
20- local dotnetRuntimeIdsArray=($dotnetRuntimeIds)
21- fi
22-23- if [[ -z ${enableParallelBuilding-} ]]; then
24- local -r parallelFlag="--disable-parallel"
25- fi
26-27- if [[ -v dotnetSelfContainedBuild ]]; then
28- if [[ -n $dotnetSelfContainedBuild ]]; then
29- dotnetRestoreFlagsArray+=("-p:SelfContained=true")
30- else
31- dotnetRestoreFlagsArray+=("-p:SelfContained=false")
32- fi
33- fi
34-35- dotnetRestore() {
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" \
43- ${parallelFlag-} \
44- "${dotnetRestoreFlagsArray[@]}" \
45- "${dotnetFlagsArray[@]}"
46- done
47- }
48-49- if [[ -f .config/dotnet-tools.json || -f dotnet-tools.json ]]; then
50- dotnet tool restore
51- fi
52-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
59- # projects.
60- if [[ -z ${dotnetGlobalTool-} ]]; then
61- if (( ${#dotnetProjectFilesArray[@]} == 0 )); then
62- dotnetRestore
63- fi
64-65- local projectFile
66- for projectFile in "${dotnetProjectFilesArray[@]}" "${dotnetTestProjectFilesArray[@]}"; do
67- dotnetRestore "$projectFile"
68- done
69- fi
70-71- runHook postConfigure
72-73- echo "Finished dotnetConfigureHook"
74-}
75-76-if [[ -z "${dontDotnetConfigure-}" && -z "${configurePhase-}" ]]; then
77- configurePhase=dotnetConfigureHook
78-fi
···1-# For compatibility, convert makeWrapperArgs to an array unless we are using
2-# structured attributes. That is, we ensure that makeWrapperArgs is always an
3-# array.
4-# See https://github.com/NixOS/nixpkgs/blob/858f4db3048c5be3527e183470e93c1a72c5727c/pkgs/build-support/dotnet/build-dotnet-module/hooks/dotnet-fixup-hook.sh#L1-L3
5-# and https://github.com/NixOS/nixpkgs/pull/313005#issuecomment-2175482920
6-if [[ -z $__structuredAttrs ]]; then
7- makeWrapperArgs=( ${makeWrapperArgs-} )
8-fi
9-10-# First argument is the executable you want to wrap,
11-# the second is the destination for the wrapper.
12-wrapDotnetProgram() {
13- local -r dotnetRuntime=@dotnetRuntime@
14- local -r wrapperPath=@wrapperPath@
15-16- local -r dotnetFromEnvScript='dotnetFromEnv() {
17- local dotnetPath
18- if command -v dotnet 2>&1 >/dev/null; then
19- dotnetPath=$(which dotnet) && \
20- dotnetPath=$(realpath "$dotnetPath") && \
21- dotnetPath=$(dirname "$dotnetPath") && \
22- export DOTNET_ROOT="$dotnetPath"
23- fi
24-}
25-dotnetFromEnv'
26-27- if [[ -n $__structuredAttrs ]]; then
28- local -r dotnetRuntimeDepsArray=( "${dotnetRuntimeDeps[@]}" )
29- else
30- local -r dotnetRuntimeDepsArray=($dotnetRuntimeDeps)
31- fi
32-33- local dotnetRuntimeDepsFlags=()
34- if (( ${#dotnetRuntimeDepsArray[@]} > 0 )); then
35- local libraryPathArray=("${dotnetRuntimeDepsArray[@]/%//lib}")
36- local OLDIFS="$IFS" IFS=':'
37- dotnetRuntimeDepsFlags+=("--suffix" "LD_LIBRARY_PATH" ":" "${libraryPathArray[*]}")
38- IFS="$OLDIFS"
39- fi
40-41- local dotnetRootFlagsArray=()
42- if [[ -z ${dotnetSelfContainedBuild-} ]]; then
43- if [[ -n ${useDotnetFromEnv-} ]]; then
44- # if dotnet CLI is available, set DOTNET_ROOT based on it. Otherwise set to default .NET runtime
45- dotnetRootFlagsArray+=("--suffix" "PATH" ":" "$wrapperPath")
46- dotnetRootFlagsArray+=("--run" "$dotnetFromEnvScript")
47- if [[ -n $dotnetRuntime ]]; then
48- dotnetRootFlagsArray+=("--set-default" "DOTNET_ROOT" "$dotnetRuntime/share/dotnet")
49- dotnetRootFlagsArray+=("--suffix" "PATH" ":" "$dotnetRuntime/bin")
50- fi
51- elif [[ -n $dotnetRuntime ]]; then
52- dotnetRootFlagsArray+=("--set" "DOTNET_ROOT" "$dotnetRuntime/share/dotnet")
53- dotnetRootFlagsArray+=("--prefix" "PATH" ":" "$dotnetRuntime/bin")
54- fi
55- fi
56-57- makeWrapper "$1" "$2" \
58- "${dotnetRuntimeDepsFlags[@]}" \
59- "${dotnetRootFlagsArray[@]}" \
60- "${gappsWrapperArgs[@]}" \
61- "${makeWrapperArgs[@]}"
62-63- echo "installed wrapper to "$2""
64-}
65-66-dotnetFixupHook() {
67- local -r dotnetInstallPath="${dotnetInstallPath-$out/lib/$pname}"
68-69- local executable executableBasename
70-71- # check if dotnetExecutables is declared (including empty values, in which case we generate no executables)
72- if declare -p dotnetExecutables &>/dev/null; then
73- if [[ -n $__structuredAttrs ]]; then
74- local dotnetExecutablesArray=( "${dotnetExecutables[@]}" )
75- else
76- local dotnetExecutablesArray=($dotnetExecutables)
77- fi
78- for executable in "${dotnetExecutablesArray[@]}"; do
79- executableBasename=$(basename "$executable")
80-81- local path="$dotnetInstallPath/$executable"
82-83- if test -x "$path"; then
84- wrapDotnetProgram "$path" "$out/bin/$executableBasename"
85- else
86- echo "Specified binary \"$executable\" is either not an executable or does not exist!"
87- echo "Looked in $path"
88- exit 1
89- fi
90- done
91- else
92- while IFS= read -d '' executable; do
93- executableBasename=$(basename "$executable")
94- wrapDotnetProgram "$executable" "$out/bin/$executableBasename" \;
95- done < <(find "$dotnetInstallPath" ! -name "*.dll" -executable -type f -print0)
96- fi
97-}
98-99-if [[ -z "${dontFixup-}" && -z "${dontDotnetFixup-}" ]]; then
100- appendToVar preFixupPhases dotnetFixupHook
101-fi
···64 postPatch = ''
65 chmod +x install-scripts/meson_install_schemas.py # patchShebangs requires executable file
66 patchShebangs install-scripts/meson_install_schemas.py
67- 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
68 '';
6970 meta = with lib; {
···64 postPatch = ''
65 chmod +x install-scripts/meson_install_schemas.py # patchShebangs requires executable file
66 patchShebangs install-scripts/meson_install_schemas.py
67+ 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
68 '';
6970 meta = with lib; {
···42# as bootloader for various platforms and corresponding binary and helper files.
43stdenv.mkDerivation (finalAttrs: {
44 pname = "limine";
45- version = "9.5.1";
4647 # We don't use the Git source but the release tarball, as the source has a
48 # `./bootstrap` script performing network access to download resources.
49 # Packaging that in Nix is very cumbersome.
50 src = fetchurl {
51 url = "https://github.com/limine-bootloader/limine/releases/download/v${finalAttrs.version}/limine-${finalAttrs.version}.tar.gz";
52- hash = "sha256-UgY8S+XGlSnO1k98JWBfSN0/IY3LANVFgJwI1kdPAcU=";
53 };
5455 enableParallelBuilding = true;
···42# as bootloader for various platforms and corresponding binary and helper files.
43stdenv.mkDerivation (finalAttrs: {
44 pname = "limine";
45+ version = "9.5.4";
4647 # We don't use the Git source but the release tarball, as the source has a
48 # `./bootstrap` script performing network access to download resources.
49 # Packaging that in Nix is very cumbersome.
50 src = fetchurl {
51 url = "https://github.com/limine-bootloader/limine/releases/download/v${finalAttrs.version}/limine-${finalAttrs.version}.tar.gz";
52+ hash = "sha256-X0dStbsBJyFDUG25G4PUZInp+yVG3+p3bfhwQL280ig=";
53 };
5455 enableParallelBuilding = true;
···446 CHOWTapeModel = chow-tape-model; # Added 2024-06-12
447 chromatic = throw "chromatic has been removed due to being unmaintained and failing to build"; # Added 2025-04-18
448 chrome-gnome-shell = gnome-browser-connector; # Added 2022-07-27
449- cinnamon = throw "The cinnamon scope has been removed and all packages have been moved to the top-level"; # Added 2024-11-25
450 citra = throw "citra has been removed from nixpkgs, as it has been taken down upstream"; # added 2024-03-04
451 citra-nightly = throw "citra-nightly has been removed from nixpkgs, as it has been taken down upstream"; # added 2024-03-04
452 citra-canary = throw "citra-canary has been removed from nixpkgs, as it has been taken down upstream"; # added 2024-03-04
···446 CHOWTapeModel = chow-tape-model; # Added 2024-06-12
447 chromatic = throw "chromatic has been removed due to being unmaintained and failing to build"; # Added 2025-04-18
448 chrome-gnome-shell = gnome-browser-connector; # Added 2022-07-27
449+ cinnamon-common = cinnamon; # Added 2025-08-06
450 citra = throw "citra has been removed from nixpkgs, as it has been taken down upstream"; # added 2024-03-04
451 citra-nightly = throw "citra-nightly has been removed from nixpkgs, as it has been taken down upstream"; # added 2024-03-04
452 citra-canary = throw "citra-canary has been removed from nixpkgs, as it has been taken down upstream"; # added 2024-03-04