commit 1b366cb92b2640816c54df8af17c8d3914f088dd · pyrox.dev/nixpkgs

+1 -1

doc/languages-frameworks/dotnet.section.md

···

       71
       71
        
       

     

       72
       72
        
       To package Dotnet applications, you can use `buildDotnetModule`. This has similar arguments to `stdenv.mkDerivation`, with the following additions:

     

       73
       73
        
       

     

       74
       74
       -
       * `projectFile` has to be used for specifying the dotnet project file relative to the source root. These usually have `.sln` or `.csproj` file extensions.

     

       74
       74
       +
       * `projectFile` has to be used for specifying the dotnet project file relative to the source root. These usually have `.sln` or `.csproj` file extensions. This can be an array of multiple projects as well.

     

       75
       75
        
       * `nugetDeps` has to be used to specify the NuGet dependency file. Unfortunately, these cannot be deterministically fetched without a lockfile. This file should be generated using `nuget-to-nix` tool, which is available in nixpkgs.

     

       76
       76
        
       * `executables` is used to specify which executables get wrapped to `$out/bin`, relative to `$out/lib/$pname`. If this is unset, all executables generated will get installed. If you do not want to install any, set this to `[]`.

     

       77
       77
        
       * `runtimeDeps` is used to wrap libraries into `LD_LIBRARY_PATH`. This is how dotnet usually handles runtime dependencies.

+45 -37

pkgs/build-support/build-dotnet-module/default.nix

···

       21
       21
        
       # Unfortunately, dotnet has no method for doing this automatically.

     

       22
       22
        
       # If unset, all executables in the projects root will get installed. This may cause bloat!

     

       23
       23
        
       , executables ? null

     

       24
       24
       -
       # The packages project file, which contains instructions on how to compile it.

     

       24
       24
       +
       # The packages project file, which contains instructions on how to compile it. This can be an array of multiple project files as well.

     

       25
       25
        
       , projectFile ? null

     

       26
       26
        
       # The NuGet dependency file. This locks all NuGet dependency versions, as otherwise they cannot be deterministically fetched.

     

       27
       27
        
       # This can be generated using the `nuget-to-nix` tool.

     
···

       102
       102
        
       

     

       103
       103
        
             export HOME=$(mktemp -d)

     

       104
       104
        
       

     

       105
       105
       -
             dotnet restore "$projectFile" \

     

       106
       106
       -
               ${lib.optionalString (!enableParallelBuilding) "--disable-parallel"} \

     

       107
       107
       -
               -p:ContinuousIntegrationBuild=true \

     

       108
       108
       -
               -p:Deterministic=true \

     

       109
       109
       -
               --source "${nuget-source}/lib" \

     

       110
       110
       -
               "''${dotnetRestoreFlags[@]}" \

     

       111
       111
       -
               "''${dotnetFlags[@]}"

     

       105
       105
       +
             for project in ''${projectFile[@]}; do

     

       106
       106
       +
               dotnet restore "$project" \

     

       107
       107
       +
                 ${lib.optionalString (!enableParallelBuilding) "--disable-parallel"} \

     

       108
       108
       +
                 -p:ContinuousIntegrationBuild=true \

     

       109
       109
       +
                 -p:Deterministic=true \

     

       110
       110
       +
                 --source "${nuget-source}/lib" \

     

       111
       111
       +
                 "''${dotnetRestoreFlags[@]}" \

     

       112
       112
       +
                 "''${dotnetFlags[@]}"

     

       113
       113
       +
             done

     

       112
       114
        
       

     

       113
       115
        
             runHook postConfigure

     

       114
       116
        
           '';

     
···

       116
       118
        
           buildPhase = args.buildPhase or ''

     

       117
       119
        
             runHook preBuild

     

       118
       120
        
       

     

       119
       119
       -
             dotnet build "$projectFile" \

     

       120
       120
       -
               -maxcpucount:${if enableParallelBuilding then "$NIX_BUILD_CORES" else "1"} \

     

       121
       121
       -
               -p:BuildInParallel=${if enableParallelBuilding then "true" else "false"} \

     

       122
       122
       -
               -p:ContinuousIntegrationBuild=true \

     

       123
       123
       -
               -p:Deterministic=true \

     

       124
       124
       -
               -p:Version=${args.version} \

     

       125
       125
       -
               --configuration "$buildType" \

     

       126
       126
       -
               --no-restore \

     

       127
       127
       -
               "''${dotnetBuildFlags[@]}"  \

     

       128
       128
       -
               "''${dotnetFlags[@]}"

     

       121
       121
       +
             for project in ''${projectFile[@]}; do

     

       122
       122
       +
               dotnet build "$project" \

     

       123
       123
       +
                 -maxcpucount:${if enableParallelBuilding then "$NIX_BUILD_CORES" else "1"} \

     

       124
       124
       +
                 -p:BuildInParallel=${if enableParallelBuilding then "true" else "false"} \

     

       125
       125
       +
                 -p:ContinuousIntegrationBuild=true \

     

       126
       126
       +
                 -p:Deterministic=true \

     

       127
       127
       +
                 -p:Version=${args.version} \

     

       128
       128
       +
                 --configuration "$buildType" \

     

       129
       129
       +
                 --no-restore \

     

       130
       130
       +
                 "''${dotnetBuildFlags[@]}"  \

     

       131
       131
       +
                 "''${dotnetFlags[@]}"

     

       132
       132
       +
             done

     

       129
       133
        
       

     

       130
       134
        
             runHook postBuild

     

       131
       135
        
           '';

     
···

       133
       137
        
           checkPhase = args.checkPhase or ''

     

       134
       138
        
             runHook preCheck

     

       135
       139
        
       

     

       136
       136
       -
             ${lib.getBin dotnet-test-sdk}/bin/dotnet test "$testProjectFile" \

     

       137
       137
       -
               -maxcpucount:${if enableParallelBuilding then "$NIX_BUILD_CORES" else "1"} \

     

       138
       138
       -
               -p:ContinuousIntegrationBuild=true \

     

       139
       139
       -
               -p:Deterministic=true \

     

       140
       140
       -
               --configuration "$buildType" \

     

       141
       141
       -
               --no-build \

     

       142
       142
       -
               --logger "console;verbosity=normal" \

     

       143
       143
       -
               ${lib.optionalString (disabledTests != []) "--filter \"FullyQualifiedName!=${lib.concatStringsSep "|FullyQualifiedName!=" disabledTests}\""} \

     

       144
       144
       -
               "''${dotnetTestFlags[@]}"  \

     

       145
       145
       -
               "''${dotnetFlags[@]}"

     

       140
       140
       +
             for project in ''${testProjectFile[@]}; do

     

       141
       141
       +
               ${lib.getBin dotnet-test-sdk}/bin/dotnet test "$project" \

     

       142
       142
       +
                 -maxcpucount:${if enableParallelBuilding then "$NIX_BUILD_CORES" else "1"} \

     

       143
       143
       +
                 -p:ContinuousIntegrationBuild=true \

     

       144
       144
       +
                 -p:Deterministic=true \

     

       145
       145
       +
                 --configuration "$buildType" \

     

       146
       146
       +
                 --no-build \

     

       147
       147
       +
                 --logger "console;verbosity=normal" \

     

       148
       148
       +
                 ${lib.optionalString (disabledTests != []) "--filter \"FullyQualifiedName!=${lib.concatStringsSep "&FullyQualifiedName!=" disabledTests}\""} \

     

       149
       149
       +
                 "''${dotnetTestFlags[@]}"  \

     

       150
       150
       +
                 "''${dotnetFlags[@]}"

     

       151
       151
       +
             done

     

       146
       152
        
       

     

       147
       153
        
             runHook postCheck

     

       148
       154
        
           '';

     
···

       150
       156
        
           installPhase = args.installPhase or ''

     

       151
       157
        
             runHook preInstall

     

       152
       158
        
       

     

       153
       153
       -
             dotnet publish "$projectFile" \

     

       154
       154
       -
               -p:ContinuousIntegrationBuild=true \

     

       155
       155
       -
               -p:Deterministic=true \

     

       156
       156
       -
               --output $out/lib/${args.pname} \

     

       157
       157
       -
               --configuration "$buildType" \

     

       158
       158
       -
               --no-build \

     

       159
       159
       -
               --no-self-contained \

     

       160
       160
       -
               "''${dotnetInstallFlags[@]}"  \

     

       161
       161
       -
               "''${dotnetFlags[@]}"

     

       159
       159
       +
             for project in ''${projectFile[@]}; do

     

       160
       160
       +
               dotnet publish "$project" \

     

       161
       161
       +
                 -p:ContinuousIntegrationBuild=true \

     

       162
       162
       +
                 -p:Deterministic=true \

     

       163
       163
       +
                 --output $out/lib/${args.pname} \

     

       164
       164
       +
                 --configuration "$buildType" \

     

       165
       165
       +
                 --no-build \

     

       166
       166
       +
                 --no-self-contained \

     

       167
       167
       +
                 "''${dotnetInstallFlags[@]}"  \

     

       168
       168
       +
                 "''${dotnetFlags[@]}"

     

       169
       169
       +
             done

     

       162
       170
        
           '' + (if executables != null then ''

     

       163
       171
        
             for executable in $executables; do

     

       164
       172
        
               execPath="$out/lib/${args.pname}/$executable"