private static async Task Run(Options options)
{
// Set up NuGet stuff
sourceCache = new();
sourceRepository = Repository.Factory.GetCoreV3("https://api.nuget.org/v3/index.json");
searchResource = await sourceRepository.GetResourceAsync <PackageSearchResource>();
updateResource = await sourceRepository.GetResourceAsync <PackageUpdateResource>();
findByIdResource = await sourceRepository.GetResourceAsync <FindPackageByIdResource>();
// Search for the nightly package IDs that were just built
var localPackageIds = GetLocalNightlyPackageIds(options);
// Search for the remotely published packages
var remotePackageIds = await GetRemotePackageIds(options);
// If there are differences, that means we removed/renmed something
// In those cases, unist/deprecate all versions
var toCompletelyUnlist = remotePackageIds.Except(localPackageIds).ToList();
foreach (var packageId in toCompletelyUnlist)
{
await DeleteAllVersionsOfPackage(options, packageId);
}
// Now for each package that exists on remote, we want to unlish the nightly versions
// These are packages that are both present locally and on remote
var toUnlistNightly = localPackageIds.Intersect(remotePackageIds).ToList();
foreach (var packageId in toUnlistNightly)
{
await DeleteAllNightlyVersionsOfPackage(options, packageId);
}
}
/// <summary>
/// Pushes a set of packages from .nupkg files that must exist in <see cref="CheckRepositoryInfo.ReleasesFolder"/>.
/// </summary>
/// <param name="pushes">The instances to push (that necessary target this feed).</param>
/// <returns>The awaitable.</returns>
public override async Task PushAsync(IEnumerable <ArtifactPush> pushes)
{
string apiKey = null;
if (!_packageSource.IsLocal)
{
apiKey = ResolveAPIKey();
if (string.IsNullOrEmpty(apiKey))
{
Cake.Information($"Could not resolve API key. Push to '{Name}' => '{Url}' is skipped.");
return;
}
}
Cake.Information($"Pushing packages to '{Name}' => '{Url}'.");
ILogger logger = InitializeAndGetLogger(Cake);
PackageUpdateResource updater = await _updater;
foreach (ArtifactPush p in pushes)
{
string packageString = p.Name + "." + p.Version.WithBuildMetaData(null).ToNormalizedString();
NormalizedPath fullPath = ArtifactType.GlobalInfo.ReleasesFolder.AppendPart(packageString + ".nupkg");
await updater.Push(
fullPath,
string.Empty, // no Symbol source.
20, //20 seconds timeout
disableBuffering : false,
getApiKey : endpoint => apiKey,
getSymbolApiKey : symbolsEndpoint => null,
noServiceEndpoint : false,
log : logger);
}
await OnAllArtifactsPushed(pushes);
}
private static async Task DeletePackageAsync()
{
try
{
// This code region is referenced by the NuGet docs. Please update the docs if you rename the region
// or move it to a different file.
#region DeletePackage
ILogger logger = NullLogger.Instance;
CancellationToken cancellationToken = CancellationToken.None;
SourceCacheContext cache = new SourceCacheContext();
SourceRepository repository = Repository.Factory.GetCoreV3("https://api.nuget.org/v3/index.json");
PackageUpdateResource resource = await repository.GetResourceAsync <PackageUpdateResource>();
string apiKey = "my-api-key";
await resource.Delete(
"MyPackage",
"1.0.0-beta",
getApiKey : packageSource => apiKey,
confirm : packageSource => true,
noServiceEndpoint : false,
logger);
#endregion
}
catch (Exception e)
{
Console.WriteLine($"Deleting package failed: {e}");
}
}
private static async Task PushPackageAsync()
{
try
{
// This code region is referenced by the NuGet docs. Please update the docs if you rename the region
// or move it to a different file.
#region PushPackage
ILogger logger = NullLogger.Instance;
CancellationToken cancellationToken = CancellationToken.None;
SourceCacheContext cache = new SourceCacheContext();
SourceRepository repository = Repository.Factory.GetCoreV3("https://api.nuget.org/v3/index.json");
PackageUpdateResource resource = await repository.GetResourceAsync <PackageUpdateResource>();
string apiKey = "my-api-key";
await resource.Push(
"MyPackage.nupkg",
symbolSource : null,
timeoutInSecond : 5 * 60,
disableBuffering : false,
getApiKey : packageSource => apiKey,
getSymbolApiKey : packageSource => null,
noServiceEndpoint : false,
skipDuplicate : false,
symbolPackageUpdateResource : null,
logger);
#endregion
}
catch (Exception e)
{
Console.WriteLine($"Pushing package failed: {e}");
}
}
private async Task PushPackagesAsync(PackageUpdateResource packageUpdateResource)
{
while (_packages.TryTake(out var package))
{
await PushPackageAsync(packageUpdateResource, package);
}
}
private static async Task PushPackagesAsync(
PackageUpdateResource packageUpdateResource,
ConcurrentBag <PackageInfo> concurrentBag,
string apiKey)
{
while (concurrentBag.TryTake(out var package))
{
await PushPackageAsync(packageUpdateResource, package, apiKey);
}
}
NuGetFeed(NuGetArtifactType type, PackageSource s)
: base(type)
{
_packageSource = s;
_sourceRepository = new SourceRepository(_packageSource, _providers);
_updater = new AsyncLazy <PackageUpdateResource>(async() =>
{
PackageUpdateResource r = await _sourceRepository.GetResourceAsync <PackageUpdateResource>();
// TODO: Update for next NuGet version?
// r.Settings = _settings;
return(r);
});
}
public static async Task UploadPackageAsync
(
PackageUpdateResource uploadResource,
bool noServiceEndpoint,
string packagePath,
string apiKey,
SymbolPackageUpdateResourceV3 symbolsResource
)
{
if (symbolsResource is not null && IsValidSymbols(packagePath))
{
await uploadResource.Push
(
packagePath, symbolsResource.SourceUri.ToString(), 600, false, _ => apiKey, _ => apiKey,
noServiceEndpoint, true, symbolsResource,
NukeLoggerAdapter.Instance
);
}
private static async Task PushPackageAsync(
PackageUpdateResource packageUpdateResource,
PackageInfo package,
string apiKey)
{
for (var attempt = 1; attempt <= _maxRetryCount; attempt++)
{
// Fail fast if a parallel push operation has already failed
_packagePushCancellationTokenSource.Token.ThrowIfCancellationRequested();
Log.WriteInformation($"Attempting to publish package {package.Identity} (Attempt: {attempt})");
try
{
await packageUpdateResource.Push(
package.PackagePath,
symbolSource : null,
timeoutInSecond : (int)_packagePushTimeout.TotalSeconds,
disableBuffering : false,
getApiKey : _ => apiKey,
getSymbolApiKey : _ => null,
log : NullLogger.Instance);
Log.WriteInformation($"Done publishing package {package.Identity}");
return;
}
catch (Exception ex) when(attempt < _maxRetryCount) // allow exception to be thrown at the last attempt
{
// Write in a single call as multiple WriteLine statements can get interleaved causing
// confusion when reading logs.
Log.WriteInformation(
$"Attempt {attempt} failed to publish package {package.Identity}." +
Environment.NewLine +
ex.ToString() +
Environment.NewLine +
"Retrying...");
}
catch
{
_packagePushCancellationTokenSource.Cancel();
throw;
}
}
}
public static async Task Run(
ISettings settings,
IPackageSourceProvider sourceProvider,
string packagePath,
string source,
string apiKey,
int timeoutSeconds,
bool disableBuffering,
bool noSymbols,
ILogger logger)
{
source = CommandRunnerUtility.ResolveSource(sourceProvider, source);
if (timeoutSeconds == 0)
{
timeoutSeconds = 5 * 60;
}
PackageUpdateResource packageUpdateResource = await CommandRunnerUtility.GetPackageUpdateResource(sourceProvider, source);
// only push to SymbolSource when the actual package is being pushed to the official NuGet.org
string symbolsSource = string.Empty;
Uri sourceUri = packageUpdateResource.SourceUri;
if (!noSymbols && !sourceUri.IsFile && sourceUri.IsAbsoluteUri)
{
if (sourceUri.Host.Equals(NuGetConstants.NuGetHostName, StringComparison.OrdinalIgnoreCase) || // e.g. nuget.org
sourceUri.Host.EndsWith("." + NuGetConstants.NuGetHostName, StringComparison.OrdinalIgnoreCase)) // *.nuget.org, e.g. www.nuget.org
{
symbolsSource = NuGetConstants.DefaultSymbolServerUrl;
}
}
await packageUpdateResource.Push(
packagePath,
symbolsSource,
timeoutSeconds,
disableBuffering,
endpoint => CommandRunnerUtility.GetApiKey(settings, endpoint, apiKey),
logger);
}
private async Task PushPackageAsync(PackageUpdateResource packageUpdateResource, PackageInfo package)
{
for (var attempt = 1; attempt <= _maxRetryCount; attempt++)
{
// Fail fast if a parallel push operation has already failed
_packagePushCancellationTokenSource.Token.ThrowIfCancellationRequested();
Log.LogMessage($"Attempting to publish package {package.Identity} (Attempt: {attempt})");
try
{
await packageUpdateResource.Push(
package.PackagePath,
symbolSource : null,
timeoutInSecond : TimeoutSeconds,
disableBuffering : false,
getApiKey : _ => ApiKey,
getSymbolApiKey : _ => null,
noServiceEndpoint : false,
log : NullLogger.Instance);
Log.LogMessage(MessageImportance.High, $"Published package {package.Identity}");
return;
}
catch (Exception ex) when(attempt < _maxRetryCount) // allow exception to be thrown at the last attempt
{
Log.LogMessage(
MessageImportance.High,
$"Attempt {attempt} failed to publish package {package.Identity}." +
Environment.NewLine +
ex +
Environment.NewLine +
"Retrying...");
}
catch
{
_packagePushCancellationTokenSource.Cancel();
throw;
}
}
}
public static async Task Run(
ISettings settings,
IPackageSourceProvider sourceProvider,
string packageId,
string packageVersion,
string source,
string apiKey,
bool nonInteractive,
Func <string, bool> confirmFunc,
ILogger logger)
{
source = CommandRunnerUtility.ResolveSource(sourceProvider, source);
PackageUpdateResource packageUpdateResource = await CommandRunnerUtility.GetPackageUpdateResource(sourceProvider, source);
await packageUpdateResource.Delete(
packageId,
packageVersion,
(endpoint) => CommandRunnerUtility.GetApiKey(settings, endpoint, apiKey),
(desc) => nonInteractive?true : confirmFunc(desc),
logger);
}
private static async Task <int> PushAllAsync(string source, string symbolSource, IReadOnlyList <string> packages, string apiKey)
{
SourceRepository sourceRepository = ConfigureSourceRepository(source);
PackageUpdateResource packageUpdateResource = await sourceRepository.GetResourceAsync <PackageUpdateResource>();
Console.WriteLine($"Pushing Packages to: {packageUpdateResource.SourceUri}");
SymbolPackageUpdateResourceV3?symbolPackageUpdateResource = await GetSymbolPackageUpdateSourceAsync(sourceRepository);
PackageUpdateResource?symbolPackageUpdateResourceAsPackage = null;
SourceRepository?symbolSourceRepository = null;
if (!string.IsNullOrWhiteSpace(symbolSource) && symbolPackageUpdateResource == null)
{
symbolSourceRepository = ConfigureSourceRepository(symbolSource);
PackageUpdateResource?resource = await symbolSourceRepository.GetResourceAsync <PackageUpdateResource>();
if (resource?.SourceUri != null)
{
Console.WriteLine($"Pushing Symbol Packages to: {resource.SourceUri}");
symbolPackageUpdateResourceAsPackage = resource;
}
}
IReadOnlyList <string> symbolPackages = ExtractSymbolPackages(packages);
IReadOnlyList <string> nonSymbolPackages = ExtractProductionPackages(packages);
IEnumerable <Task <(string package, bool success)> > tasks = BuildUploadTasks(symbolSourceRepository: symbolSourceRepository,
symbolPackageUpdateResource: symbolPackageUpdateResource,
symbolPackageUpdateResourceAsPackage: symbolPackageUpdateResourceAsPackage,
nonSymbolPackages: nonSymbolPackages,
symbolPackages: symbolPackages,
apiKey: apiKey,
packageUpdateResource: packageUpdateResource);
(string package, bool success)[] results = await Task.WhenAll(tasks);
public async override Task <Tuple <bool, INuGetResource> > TryCreate(
SourceRepository source,
CancellationToken token)
{
HttpSource httpSource = null;
PackageUpdateResource packageUpdateResource = null;
var sourceUri = source.PackageSource?.Source;
if (!string.IsNullOrEmpty(sourceUri))
{
if (source.PackageSource.IsHttp)
{
var httpSourceResource = await source.GetResourceAsync <HttpSourceResource>(token);
httpSource = httpSourceResource.HttpSource;
}
packageUpdateResource = new PackageUpdateResource(sourceUri, httpSource);
}
var result = new Tuple <bool, INuGetResource>(packageUpdateResource != null, packageUpdateResource);
return(result);
}
public override async Task <Tuple <bool, INuGetResource> > TryCreate(
SourceRepository source,
CancellationToken token)
{
PackageUpdateResource packageUpdateResource = null;
var serviceIndex = await source.GetResourceAsync <ServiceIndexResourceV3>(token);
if (serviceIndex != null)
{
var baseUrl = serviceIndex[ServiceTypes.PackagePublish].FirstOrDefault();
HttpSource httpSource = null;
var sourceUri = baseUrl?.AbsoluteUri;
if (!string.IsNullOrEmpty(sourceUri))
{
if (!(new Uri(sourceUri)).IsFile)
{
var httpSourceResource = await source.GetResourceAsync <HttpSourceResource>(token);
httpSource = httpSourceResource.HttpSource;
}
packageUpdateResource = new PackageUpdateResource(sourceUri, httpSource);
}
else
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture,
Strings.PackageServerEndpoint_NotSupported,
source));
}
}
var result = new Tuple <bool, INuGetResource>(packageUpdateResource != null, packageUpdateResource);
return(result);
}
static async Task PushAsync(
FindPackageByIdResource findPackageById,
PackageUpdateResource packageUpdate,
string apiKey,
PackageIdentity identity,
string nupkgPath,
object pushedVersionsLock,
Func <string, SemaphoreSlim> getIdSemaphore,
Dictionary <string, Task <HashSet <NuGetVersion> > > pushedVersions,
object consoleLock,
bool allowRetry)
{
// Get the list of existing versions.
Task <HashSet <NuGetVersion> > versionsTask;
lock (pushedVersionsLock)
{
if (!pushedVersions.TryGetValue(identity.Id, out versionsTask))
{
versionsTask = GetVersionsAsync(findPackageById, identity.Id, consoleLock);
pushedVersions.Add(identity.Id, versionsTask);
}
}
var versions = await versionsTask;
lock (pushedVersionsLock)
{
if (versions.Contains(identity.Version))
{
return;
}
}
Console.WriteLine($" Pushing {identity.Id} {identity.Version.ToNormalizedString()}...");
try
{
var idSemaphore = getIdSemaphore(identity.Id);
await idSemaphore.WaitAsync();
try
{
await packageUpdate.Push(
nupkgPath,
symbolSource : string.Empty,
timeoutInSecond : 300,
disableBuffering : false,
getApiKey : _ => apiKey,
getSymbolApiKey : null,
noServiceEndpoint : false,
skipDuplicate : false,
symbolPackageUpdateResource : null,
log : NullLogger.Instance); // new ConsoleLogger());
}
finally
{
idSemaphore.Release();
}
lock (pushedVersionsLock)
{
versions.Add(identity.Version);
}
}
catch (HttpRequestException ex) when(ex.Message.StartsWith("Response status code does not indicate success: 409 ") && allowRetry)
{
await PushAsync(
findPackageById,
packageUpdate,
apiKey,
identity,
nupkgPath,
pushedVersionsLock,
getIdSemaphore,
pushedVersions,
consoleLock,
allowRetry : false);
}
catch (Exception ex)
{
lock (consoleLock)
{
Console.WriteLine($" Push of {identity.Id} {identity.Version.ToNormalizedString()} ({new FileInfo(nupkgPath).Length} bytes) failed with exception:");
Console.WriteLine(ex);
}
return;
}
}
