Nuget: how to retrieve generated .nupkg file location for push

[ymartin59]

Hello
I am interested to implement a generic build/push logic in a monorepo context.

My current build file generate .nupkg from csproj file with NuGetPack(project, new NuGetPackSettings { OutputDirectory = "packages/" });
And I would like then to publish file with NuGetPush(package, new NuGetPushSettings { Source: "local-source", });

Is there a way to infer/compute/retrieve generated package file path from NuGetPack command?

[pascalberger]

What I often do in generic build scripts in cases like this is to search the OutputDirectory for *.nupkg files in the publish step and then publish the found files:

var nupkgFiles = GetFiles("packages/*.nupkg");
var settings = new NuGetPushSettings { Source: "local-source" };
foreach (var nupkgFile in nupkgFiles)
{
    NuGetPush(nupkgFile, settings);
}

Here is an example using this approach in Cake.Recipe: https://github.com/cake-contrib/Cake.Recipe/blob/b72068881d7785a9429167592389e8524c4382e8/Cake.Recipe/Content/packages.cake#L252

[devlead]

If you have a csproj then I would recommend using DotNetCorePack / DotNetCoreNuGetPush utilizing .NET Core CLI.

That said you can fetch all generated nupkg files with a globber and do something like

var packages = GetFiles(outputNuGet.Path.FullPath + "/*.nupkg") -
               GetFiles(outputNuGet.Path.FullPath + "/*.symbols.nupkg");

foreach(var package in packages)
{
    NuGetPush(package, new NuGetPushSettings {
                Source = source,
                ApiKey = apiKey
    });
}

[augustoproiete]

Just a quick note that although it's common to retrieve a list of artifacts generated during the build and publish them in bulk (to make the code smaller/less repetitive), it's also a good practice to (before the publishing) validate that:

1. All the packages you expect to be published are actually present in your artifacts folder

Otherwise your build will appear to have succeeded incorrectly - as you didn't push all the packages you expected

2. No other packages are present in your artifacts folder

In case of errors in your build, you don't want to push the wrong packages to the feed

---

Here's a simple example that detects missing files as well as files that shouldn't be there, and fails the build in either case:

var version = "...";

var expectedFiles = new []
{
    MakeAbsolute(FilePath.FromString($"./packages/YourPackage.{version}.nupkg")).FullPath,
    MakeAbsolute(FilePath.FromString($"./packages/YourPackage.{version}.snupkg")).FullPath,
};

var actualFiles = GetFiles("./packages/**/*.*").Select(f => f.FullPath).ToList();

var missingFiles = expectedFiles.Except(actualFiles).ToList();
foreach (var missingFile in missingFiles)
{
    Error("Error: Artifact {0} is missing", missingFile);
}

var unexpectedFiles = actualFiles.Except(expectedFiles).ToList();
foreach (var unexpectedFile in unexpectedFiles)
{
    Error("Error: Artifact {0} was not expected", unexpectedFile);
}

if (missingFiles.Count > 0 || unexpectedFiles.Count > 0)
{
    throw new CakeException();
}

[ymartin59]

Thanks for all your proposals @devlead @augustoproiete @pascalberger

It would have been far simpler if NuGetPack may return a "FilePath" object value...

To reduce code (do not query version from assembly) and avoid error prone logic (id/version expectations), I made my mind for this sequence (in each single-project build task):

• create an empty temporary folder for each project /packages/<projectid>/
• pack there
• retrieve file with glob pattern (I expect there is only one)
• push
• move file to /packages/ for future use/investigation
• delete temporary folder

I guess it will be easy to read/understand/maintain for others.
Again thank you for your help

[augustoproiete]

Indeed. It would be useful if NuGetPack returned the list of files that were created - it wouldn't be impossible to implement that in Cake today, but it would be quite brittle given that we'd have to parse free text in the output, which looks something like this:

Microsoft (R) Build Engine version 16.8.3+39993bd9d for .NET
Copyright (C) Microsoft Corporation. All rights reserved.

  Successfully created package 'C:\project\artifacts\PackageId.Version.nupkg'.
  Successfully created package 'C:\project\artifacts\PackageId.Version.snupkg'.

Keeping in mind that:

• dotnet pack can create symbols packages (.snupkg / .symbols.nupkg) in addition to the .nupkg
• dotnet pack MyApp.sln also works and creates a package for every single project in the solution (unless packing is disabled via <IsPackable>false</IsPackable>) thus a number of files created by a single command

The above seems like it would be a better fit for a Cake Addin, until dotnet pack implements a way to output structured data in some machine-readable format e.g. dotnet pack MyApp.csproj --output json

---

To reduce code (do not query version from assembly)

There are many approaches to versioning, but nowadays it's less common to have the full version defined in the csproj/assembly (and have to query it from the build script).

Usually, the version is either provided to the build script, generated by the build script, or a combination of the two. And then the assembly is stamped with that version.

You might want to take a look at a few of the versioning-related addins for Cake such as Cake.GitVersioning, Cake.MinVer, Cake.SimpleVersion, Cake.RepoVersion, and others.