public static async Task <int> RunCore(LocalSettings settings, ISleetFileSystem source, List <string> inputs, bool force, ILogger log)
{
var exitCode = 0;
var token = CancellationToken.None;
var now = DateTimeOffset.UtcNow;
// Get packages
var packages = GetPackageInputs(inputs, now, log);
// Check if already initialized
using (var feedLock = await SourceUtility.VerifyInitAndLock(source, log, token))
{
// Validate source
await UpgradeUtility.UpgradeIfNeeded(source, log, token);
// Get sleet.settings.json
var sourceSettings = new SourceSettings();
// Settings context used for all operations
var context = new SleetContext()
{
LocalSettings = settings,
SourceSettings = sourceSettings,
Log = log,
Source = source,
Token = token
};
var packageIndex = new PackageIndex(context);
foreach (var package in packages)
{
if (await packageIndex.Exists(package.Identity))
{
if (force)
{
log.LogInformation($"Package already exists, removing {package.ToString()}");
await SleetUtility.RemovePackage(context, package.Identity);
}
else
{
throw new InvalidOperationException($"Package already exists: '{package.Identity}'.");
}
}
log.LogInformation($"Adding {package.Identity.ToString()}");
await SleetUtility.AddPackage(context, package);
}
// Save all
await source.Commit(log, token);
}
return(exitCode);
}
public static async Task <bool?> IsPackageIdenticalOnFeedAsync(string item, PackageIndex packageIndex, ISleetFileSystem source, FlatContainer flatContainer, ILogger log)
{
using (var package = new PackageArchiveReader(item))
{
var id = await package.GetIdentityAsync(CancellationToken.None);
if (await packageIndex.Exists(id))
{
using (var remoteStream = await source.Get(flatContainer.GetNupkgPath(id)).GetStream(log, CancellationToken.None))
using (var remote = new MemoryStream())
{
await remoteStream.CopyToAsync(remote);
var existingBytes = remote.ToArray();
var localBytes = File.ReadAllBytes(item);
return(existingBytes.SequenceEqual(localBytes));
}
}
return(null);
}
}
public static async Task <int> RunCore(LocalSettings settings, ISleetFileSystem source, string packageId, string version, string reason, bool force, ILogger log)
{
var exitCode = 0;
var token = CancellationToken.None;
var now = DateTimeOffset.UtcNow;
// Check if already initialized
using (var feedLock = await SourceUtility.VerifyInitAndLock(source, log, token))
{
// Validate source
await UpgradeUtility.UpgradeIfNeeded(source, log, token);
// Get sleet.settings.json
var sourceSettings = new SourceSettings();
// Settings context used for all operations
var context = new SleetContext()
{
LocalSettings = settings,
SourceSettings = sourceSettings,
Log = log,
Source = source,
Token = token
};
var packageIndex = new PackageIndex(context);
var packages = new List <PackageIdentity>();
if (!string.IsNullOrEmpty(version))
{
// Delete a single version of the package
var packageVersion = NuGetVersion.Parse(version);
packages.Add(new PackageIdentity(packageId, packageVersion));
}
else
{
// Delete all versions of the package
packages.AddRange(await packageIndex.GetPackagesById(packageId));
}
if (string.IsNullOrEmpty(reason))
{
reason = string.Empty;
}
foreach (var package in packages)
{
if (!await packageIndex.Exists(package))
{
log.LogInformation($"{package.ToString()} does not exist.");
if (force)
{
// ignore failures
continue;
}
else
{
throw new InvalidOperationException($"Package does not exists: {package.ToString()}");
}
}
log.LogInformation($"Removing {package.ToString()}");
await SleetUtility.RemovePackage(context, package);
}
// Save all
await source.Commit(log, token);
}
return(exitCode);
}
public static async Task <bool> RunAsync(LocalSettings settings, ISleetFileSystem source, string packageId, string version, string reason, bool force, ILogger log)
{
var success = true;
var token = CancellationToken.None;
var now = DateTimeOffset.UtcNow;
log.LogMinimal($"Reading feed {source.BaseURI.AbsoluteUri}");
// Check if already initialized
using (var feedLock = await SourceUtility.VerifyInitAndLock(settings, source, log, token))
{
// Validate source
await SourceUtility.ValidateFeedForClient(source, log, token);
// Get sleet.settings.json
var sourceSettings = await FeedSettingsUtility.GetSettingsOrDefault(source, log, token);
// Settings context used for all operations
var context = new SleetContext()
{
LocalSettings = settings,
SourceSettings = sourceSettings,
Log = log,
Source = source,
Token = token
};
var packageIndex = new PackageIndex(context);
var packages = new List <PackageIdentity>();
if (!string.IsNullOrEmpty(version))
{
// Delete a single version of the package
var packageVersion = NuGetVersion.Parse(version);
packages.Add(new PackageIdentity(packageId, packageVersion));
}
else
{
// Delete all versions of the package
packages.AddRange(await packageIndex.GetPackagesByIdAsync(packageId));
}
if (string.IsNullOrEmpty(reason))
{
reason = string.Empty;
}
foreach (var package in packages)
{
var exists = await packageIndex.Exists(package);
var symbolsExists = await packageIndex.SymbolsExists(package);
if (!exists && !symbolsExists)
{
log.LogInformation($"{package.ToString()} does not exist.");
if (force)
{
// ignore failures
continue;
}
else
{
throw new InvalidOperationException($"Package does not exists: {package.ToString()}");
}
}
var message = $"Removing {package.ToString()}";
if (exists && symbolsExists)
{
message = $"Removing {package.ToString()} and symbols package for {package.ToString()}";
}
else if (symbolsExists)
{
message = $"Removing symbols package {package.ToString()}";
}
await log.LogAsync(LogLevel.Information, message);
await SleetUtility.RemovePackage(context, package);
}
// Save all
log.LogMinimal($"Committing changes to {source.BaseURI.AbsoluteUri}");
success &= await source.Commit(log, token);
}
if (success)
{
log.LogMinimal($"Successfully deleted packages.");
}
else
{
log.LogError($"Failed to delete packages.");
}
return(success);
}
private static async Task PushPackage(PackageInput package, SleetContext context, PackageIndex packageIndex, bool force, bool skipExisting, ILogger log)
{
var packageString = $"{package.Identity.Id} {package.Identity.Version.ToFullString()}";
if (package.IsSymbolsPackage)
{
packageString += " Symbols";
if (!context.SourceSettings.SymbolsEnabled)
{
await log.LogAsync(LogLevel.Warning, $"Skipping {packageString}, to push symbols packages enable the symbols server on this feed.");
return;
}
}
await log.LogAsync(LogLevel.Minimal, $"Pushing {packageString}");
await log.LogAsync(LogLevel.Information, $"Checking if package exists.");
var exists = false;
if (package.IsSymbolsPackage)
{
exists = await packageIndex.SymbolsExists(package.Identity);
}
else
{
exists = await packageIndex.Exists(package.Identity);
}
if (exists)
{
if (skipExisting)
{
await log.LogAsync(LogLevel.Minimal, $"Package already exists, skipping {packageString}");
return;
}
else if (force)
{
await log.LogAsync(LogLevel.Information, $"Package already exists, removing {packageString}");
// Avoid removing both the symbols and non-symbols packages, this should only
// remove the package we are going to replace.
if (package.IsSymbolsPackage)
{
await SleetUtility.RemoveSymbolsPackage(context, package.Identity);
}
else
{
await SleetUtility.RemoveNonSymbolsPackage(context, package.Identity);
}
}
else
{
throw new InvalidOperationException($"Package already exists: {packageString}.");
}
}
await log.LogAsync(LogLevel.Information, $"Adding {packageString}");
using (package)
{
package.Zip = new ZipArchive(File.OpenRead(package.PackagePath), ZipArchiveMode.Read, leaveOpen: false);
package.Package = new PackageArchiveReader(package.Zip);
await SleetUtility.AddPackage(context, package);
}
}
